﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Globalization;
using System.Data.Common;
using System.Data.SqlClient;
using System.Transactions;


namespace DB
{
    public class Database
    {
        private DataClasses1DataContext db = new DataClasses1DataContext("Data Source=vm-idasql.ida.utb.hb.se,56001;User ID=student4;Password=tag4utnu");

        //*****************************************************************Inloggning **********************************************************//
        #region
        public bool LogIn(int id, string password)
        {
            var authentication = from p in db.Personals
                                 where (p.personalID == id && p.lösenord == password)
                                 select p;

            foreach (var p in authentication)
                return true;
            return false;
        }

        public Personal CheckLevel (int tempId)
        {
            var search = db.Personals.Single(p => p.personalID == tempId);
            return search;            
        }
        #endregion

        //**************************************************************** Privat Gäst *********************************************************//
        #region
        /// <summary>
        /// Skapar ny privatgäst
        /// </summary>
        /// <param name="forename"></param>
        /// <param name="surname"></param>
        /// <param name="address"></param>
        /// <param name="zip"></param>
        /// <param name="city"></param>
        /// <param name="phonenumber"></param>
        /// <param name="creditLimit"></param>
        /// <param name="rabatt"></param>
        /// <returns></returns>
        public Gäst NewPrivateGuest(string forename, string surname, string address, string zip,string city, string phonenumber, int creditLimit, int rabatt)
        {
            Gäst newPGuest = new Gäst(); // Skapar ny privatgäst
            newPGuest.förNamn = forename;
            newPGuest.efterNamn = surname;
            newPGuest.gatuAdress = address;
            newPGuest.postNr = zip;
            newPGuest.ort = city;
            newPGuest.telefonNr = phonenumber;
            newPGuest.kreditgräns = creditLimit;
            newPGuest.rabatt = rabatt;

            db.Gästs.InsertOnSubmit(newPGuest);
            db.SubmitChanges();
          
            return newPGuest; //returnerar den nya privatgästen. 
        }
        /// <summary>
        /// Utsökning av samtliga privatGäster
        /// </summary>
        /// <returns></returns>
        public IQueryable GetAllPGuests()
        {
            var search = from pg in db.Gästs
                         where pg.orgNr == null
                         select pg;
            return search;
        }
                
        /// <summary>
        /// Söker efter privatgäst på Gästnr och returnerar resultatet
        /// </summary>
        /// <param name="tempId"></param>
        /// <returns></returns>
        public IQueryable GetGuestById(int tempId) 
        {
            var search = from g in db.Gästs
                         where g.gästNr == tempId
                         
                         select g;

            return search;
        }

        /// <summary>
        /// Söker efter privatgäst på förnamn och returnerar resultatet
        /// </summary>
        /// <param name="tempFName"></param>
        /// <returns></returns>
        public IQueryable GetGuestByFName(string tempFName)
        {
            if (tempFName.StartsWith("*") && tempFName.EndsWith("*"))
            {
                var search = from g in db.Gästs
                             where g.förNamn.Contains(tempFName.Split('*')[1])
                             select g;
                return search;
            }
            else if (tempFName.StartsWith("*"))
            {
                var search = from g in db.Gästs
                             where g.förNamn.EndsWith(tempFName.Split('*')[1])
                             select g;
                return search;
            }
            else if (tempFName.EndsWith("*"))
            {
                var search = from g in db.Gästs
                             where g.förNamn.StartsWith(tempFName.Split('*')[0])
                             select g;
                return search;
            }
            else
            {
                var search = from g in db.Gästs
                             where g.förNamn == tempFName
                             select g;
                return search;
            }
        }

        /// <summary>
        ///  Söker efter privatgäst på efternamn och returnerar resultatet
        /// </summary>
        /// <param name="tempLName"></param>
        /// <returns></returns>
        public IQueryable GetGuestByLName(string tempLName)
        {
            if (tempLName.StartsWith("*") && tempLName.EndsWith("*"))
            {
                var search = from g in db.Gästs
                             where g.efterNamn.Contains(tempLName.Split('*')[1])
                             select g;
                return search;
            }
            else if (tempLName.StartsWith("*"))
            {
                var search = from g in db.Gästs
                             where g.efterNamn.EndsWith(tempLName.Split('*')[1])
                             select g;
                return search;
            }
            else if (tempLName.EndsWith("*"))
            {
                var search = from g in db.Gästs
                             where g.efterNamn.StartsWith(tempLName.Split('*')[0])
                             select g;
                return search;
            }
            else
            {
                var search = from g in db.Gästs
                             where g.efterNamn == tempLName
                             select g;
                return search;
            }
        }

        /// <summary>
        /// Söker efter privatgäst på både förnamn och efternamn samt returnerar resultatet
        /// </summary>
        /// <param name="tempLName"></param>
        /// <param name="tempFName"></param>
        /// <returns></returns>
        public IQueryable GetGuestByName(string tempLName, string tempFName) 
        {
            if (tempFName.Contains("*") && tempLName.Contains("*"))
            {

                if (tempFName.StartsWith("*") && tempFName.EndsWith("*") && tempLName.StartsWith("*") && tempLName.EndsWith("*"))
                {
                    var search = from g in db.Gästs
                                 where g.förNamn.Contains(tempFName.Split('*')[1]) && g.efterNamn.Contains(tempLName.Split('*')[1])
                                 select g;
                    return search;
                }
                else if (tempFName.StartsWith("*") && tempFName.EndsWith("*") && tempLName.EndsWith("*"))
                {
                    var search = from g in db.Gästs
                                 where g.förNamn.Contains(tempFName.Split('*')[1]) && g.efterNamn.StartsWith(tempLName.Split('*')[0])
                                 select g;
                    return search;
                }
                else if (tempFName.StartsWith("*") && tempFName.EndsWith("*") && tempLName.StartsWith("*"))
                {
                    var search = from g in db.Gästs
                                 where g.förNamn.Contains(tempFName.Split('*')[1]) && g.efterNamn.EndsWith(tempLName.Split('*')[1])
                                 select g;
                    return search;
                }
                else if (tempFName.StartsWith("*") && tempLName.StartsWith("*") && tempLName.EndsWith("*"))
                {
                    var search = from g in db.Gästs
                                 where g.förNamn.EndsWith(tempFName.Split('*')[1]) && g.efterNamn.Contains(tempLName.Split('*')[1])
                                 select g;
                    return search;
                }
                else if (tempFName.StartsWith("*") && tempLName.StartsWith("*"))
                {
                    var search = from g in db.Gästs
                                 where g.förNamn.EndsWith(tempFName.Split('*')[1]) && g.efterNamn.EndsWith(tempLName.Split('*')[1])
                                 select g;
                    return search;
                }
                else if (tempFName.StartsWith("*") && tempLName.EndsWith("*"))
                {
                    var search = from g in db.Gästs
                                 where g.förNamn.EndsWith(tempFName.Split('*')[1]) && g.efterNamn.StartsWith(tempLName.Split('*')[0])
                                 select g;
                    return search;
                }
                else if (tempFName.EndsWith("*") && tempLName.StartsWith("*") && tempLName.EndsWith("*"))
                {
                    var search = from g in db.Gästs
                                 where g.förNamn.StartsWith(tempFName.Split('*')[0]) && g.efterNamn.Contains(tempLName.Split('*')[1])
                                 select g;
                    return search;
                }
                else if (tempFName.EndsWith("*") && tempLName.StartsWith("*"))
                {
                    var search = from g in db.Gästs
                                 where g.förNamn.StartsWith(tempFName.Split('*')[0]) && g.efterNamn.EndsWith(tempLName.Split('*')[1])
                                 select g;
                    return search;
                }
                else
                {
                    var search = from g in db.Gästs
                                 where g.förNamn.StartsWith(tempFName.Split('*')[0]) && g.efterNamn.StartsWith(tempLName.Split('*')[0])
                                 select g;
                    return search;
                }
            }
            else if (tempLName.Contains("*"))
            {

                if (tempLName.StartsWith("*") && tempLName.EndsWith("*"))
                {
                    var search = from g in db.Gästs
                                 where g.efterNamn.Contains(tempLName.Split('*')[1]) && g.förNamn == tempFName
                                 select g;
                    return search;
                }
                else if (tempLName.StartsWith("*"))
                {
                    var search = from g in db.Gästs
                                 where g.efterNamn.EndsWith(tempLName.Split('*')[1].ToLower()) && g.förNamn == tempFName
                                 select g;
                    return search;
                }
                else
                {
                    var search = from g in db.Gästs
                                 where g.efterNamn.StartsWith(tempLName.Split('*')[0]) && g.förNamn == tempFName
                                 select g;
                    return search;
                }
            }
            else if (tempFName.Contains("*"))
            {
                if (tempFName.StartsWith("*") && tempFName.EndsWith("*"))
                {
                    var search = from g in db.Gästs
                                 where g.förNamn.Contains(tempFName.Split('*')[1]) && g.efterNamn == tempLName
                                 select g;
                    return search;
                }

                else if (tempFName.StartsWith("*"))
                {
                    var search = from g in db.Gästs
                                 where g.förNamn.EndsWith(tempFName.Split('*')[1]) && g.efterNamn == tempLName
                                 select g;
                    return search;
                }
                else
                {
                    var search = from g in db.Gästs
                                 where g.förNamn.StartsWith(tempFName.Split('*')[0]) && g.efterNamn == tempLName
                                 select g;
                    return search;
                }
            }
            else
            {
                var search = from g in db.Gästs
                             where g.förNamn.StartsWith(tempFName.Split('*')[0]) && g.efterNamn.StartsWith(tempFName.Split('*')[0])
                             select g;
                return search;
            }

        }

        public int GetGuestCreditLimit(int guestNr)
        {
            int search = (from g in db.Gästs
                          where g.gästNr == guestNr
                          select g.kreditgräns).SingleOrDefault().Value;
            return search;
        }

        public void ChangedPrGuest(int tempId, string tempFname, string tempLname, string tempAddress, string tempZip, string tempCity, string tempPhone)
        {
            var search = from g in db.Gästs
                         where g.gästNr == tempId
                         select g;
            foreach (Gäst g in search)
            {
                g.förNamn = tempFname;
                g.efterNamn = tempLname;
                g.gatuAdress = tempAddress;
                g.postNr = tempZip;
                g.ort = tempCity;
                g.telefonNr = tempPhone;
            }
            db.SubmitChanges();
        }
        /// <summary>
        /// Uppdaterar rabatt o kreditgräns för specifik gäst.
        /// </summary>
        /// <param name="tempId"></param>
        /// <param name="tempDicount"></param>
        /// <param name="tempCredit"></param>
        public void ChangedGuest(int tempId, int tempDicount, int tempCredit)
        {
            var search = from g in db.Gästs
                         where g.gästNr == tempId
                         select g;

            foreach (Gäst g in search)
            {
                g.rabatt = tempDicount;
                g.kreditgräns = tempCredit;

            }

            db.SubmitChanges();
        }
        /// <summary>
        ///  Uppdaterar kredtigräns för specifik gäst efter bokning. 
        /// </summary>
        /// <param name="guestNr"></param>
        /// <param name="bookingNr"></param>
        public void UpdateGuestCredit(int guestNr, int bookingNr)
        {
            decimal bsearch = (from b in db.Boknings
                         where b.bokningsNr == bookingNr
                         select b.totSum).SingleOrDefault().Value;

            var gsearch = from g in db.Gästs
                          where g.gästNr == guestNr
                          select g;

            foreach (Gäst g in gsearch)
            {
                g.kreditgräns += Convert.ToInt16(bsearch);
            }
        }
#endregion 
        //************************************************************ Företagsgäst ************************************************************//
        #region
        /// <summary>
        /// Skapar ny företagsgäst
        /// </summary>
        /// <param name="companyName"></param>
        /// <param name="reference"></param>
        /// <param name="address"></param>
        /// <param name="zip"></param>
        /// <param name="phonenumber"></param>
        /// <param name="creditLimit"></param>
        /// <returns></returns>
        public Gäst NewCompanyGuest(string orgNr, string companyName, string reference, string address, string zip, string ort, string phonenumber, int creditLimit)
        {
            Gäst newCGuest = new Gäst();
            
            newCGuest.företagsNamn = companyName;
            newCGuest.kontaktPerson = reference;
            newCGuest.gatuAdress = address;
            newCGuest.postNr = zip;
            newCGuest.ort = ort;
            newCGuest.telefonNr = phonenumber;
            newCGuest.kreditgräns = creditLimit;
            newCGuest.orgNr = orgNr;
            newCGuest.rabatt = 0;

            db.Gästs.InsertOnSubmit(newCGuest);
            db.SubmitChanges();

            return newCGuest; //returnerar den nya företagsgästen. 
        }
        /// <summary>
        /// utsökning av specifik företagsgäst med inmatad gästnr.
        /// </summary>
        /// <param name="tempId"></param>
        /// <param name="tempOrgNr"></param>
        /// <param name="tempCompName"></param>
        /// <param name="tempRef"></param>
        /// <param name="tempAddress"></param>
        /// <param name="tempZip"></param>
        /// <param name="tempCity"></param>
        /// <param name="tempPhone"></param>
        public void ChangedCoGuest(int tempId, string tempOrgNr, string tempCompName, string tempRef, string tempAddress, string tempZip, string tempCity, string tempPhone)    // Ändringar i specifik företagsgäst
        {
            var search = from g in db.Gästs
                         where g.gästNr == tempId
                         select g;
            foreach (Gäst g in search)
            {
                g.orgNr = tempOrgNr;
                g.företagsNamn = tempCompName;
                g.kontaktPerson = tempRef;
                g.gatuAdress = tempAddress;
                g.postNr = tempZip;
                g.ort = tempCity;
                g.telefonNr = tempPhone;
            }
            db.SubmitChanges();
        }
        /// <summary>
        /// Utsökning som ger samtliga företagsgäster 
        /// </summary>
        /// <returns></returns>
        public IQueryable GetAllCoGuests()
        {
            var search = from cg in db.Gästs
                         where cg.förNamn == null
                         select cg;
            return search;
        }

        /// <summary>
        /// Söker efter företagsgäst på företagsnamn
        /// </summary>
        /// <param name="tempCoName"></param>
        /// <returns></returns>
        public IQueryable GetCoGuestByName(string tempCoName)
        {
            if (tempCoName.StartsWith("*") && tempCoName.EndsWith("*"))
            {
                var search = from g in db.Gästs
                             where g.företagsNamn.Contains(tempCoName.Split('*')[1])
                             select g;
                return search;
            }
            else if (tempCoName.StartsWith("*"))
            {
                var search = from g in db.Gästs
                             where g.företagsNamn.EndsWith(tempCoName.Split('*')[1])
                             select g;
                return search;
            }
            else if (tempCoName.EndsWith("*"))
            {
                var search = from g in db.Gästs
                             where g.företagsNamn.StartsWith(tempCoName.Split('*')[0])
                             select g;
                return search;
            }
            else
            {
                var search = from g in db.Gästs
                             where g.företagsNamn == tempCoName
                             select g;
                return search;
            }
        }

        /// <summary>
        ///
        /// Söker efter företagsgäst på organisationsnummer
        /// </summary>
        /// <param name="tempOrgNr"></param>
        /// <returns></returns>
        public IQueryable GetCoGuestByOrgNr(string tempOrgNr)
        {
            var search =  from g in db.Gästs
                          where g.orgNr.StartsWith(tempOrgNr) || g.orgNr.EndsWith(tempOrgNr)
                          select g;
                          
            return search;
        }
/// <summary>
/// Utsökning av företagsgäst på gästnr
/// </summary>
/// <param name="tempId"></param>
/// <returns></returns>
        public IQueryable GetCoGuestById(int tempId)
        {
            var search = from g in db.Gästs
                         where g.gästNr == tempId
                         select g;
            return search;
        }
        #endregion
        //**************************************************** Prislistor och Logi/Konferensinfo ***********************************************//
        #region
        /// <summary>
        /// Söker efter och returnerar logityp 
        /// </summary>
        /// <param name="tempLodg"></param>
        /// <returns></returns>
        public LogiTyp GetLodgingInfo(string tempLodg) 
        {
            var search = db.LogiTyps.SingleOrDefault(l => l.logiTyp1 == tempLodg);
            return search;
        }
        /// <summary>
        ///Söker efter och returnerar konferenstyp
        /// </summary>
        /// <param name="tempConf"></param>
        /// <returns></returns>
        public KonferensTyp GetConferensInfo(string tempConf) 
        {
            var search = db.KonferensTyps.SingleOrDefault(c => c.konferensTyp1 == tempConf);
            return search;
        }
        /// <summary>
        /// Söker efter och returnerar utrustningspris
        /// </summary>
        /// <param name="tempEquipT"></param>
        /// <param name="tempPeriod"></param>
        /// <returns></returns>
        public UtrustningsPri GetEquipmentPrice(string tempEquipT, string tempPeriod) 
        {
            var search = db.UtrustningsPris.SingleOrDefault(u => u.utrustningsTyp == tempEquipT && u.antalDagar == tempPeriod);
                         
            return search; 

        }
        #endregion
        //*********************************************************** Visa Logi/Konferens ******************************************************//
        #region
        /// <summary>
        /// Utsökning av lediga konferenser
       /// </summary>
       /// <param name="startDate"></param>
       /// <param name="endDate"></param>
       /// <param name="weeknr"></param>
       /// <returns></returns>
        public List<string> GetFreeConference(DateTime startDate, DateTime endDate, int weeknr)
        {
            var search = from c in db.Konferens
                         where !(from cr in db.KBokningsRads                                    // filtrerar bort samtliga konferenser i Kbokningsrad(Konferensbokningsrader) inom den angivna perioden.
                                 where startDate >= cr.frånDatum && endDate <= cr.tillDatum || startDate <= cr.frånDatum && endDate >= cr.tillDatum 
                                 select cr.konferensID).Contains(c.konferensID)
                         where !(from re in db.ReservationKonferens
                                 join co in db.Konferens on re.konferensID equals co.konferensID
                                 where startDate >= re.startTid && endDate <= re.slutTid ||      // filtrerar bort samtliga konferenser i reservstabellen för konferens inom den angivna perioden. 
                                 startDate <= re.startTid && endDate >= re.slutTid
                                 select re.konferensID).Contains(c.konferensID)

                         group c by c.konferensTyp into cc                                       // Grupperar konferenserna via typer o räknar på antalet för varje typ o returnernar värderna. 
                         select new { Typ = cc.Key.ToString(), Antal = cc.Count().ToString() };

            List<string> conference = new List<string>();
            foreach (var s in search)
            {
                conference.Add(s.Typ + "  " + s.Antal + "  st");
            }
            return conference;
        }


        /// <summary>
        /// Hämtar konferenspriser för den angivna perioden. 
        /// </summary>
        /// <param name="startDate"></param>
        /// <param name="endDate"></param>
        /// <param name="weekNr"></param>
        /// <returns></returns>
        public List<string> GetConferencePrice(DateTime startDate, DateTime endDate, int weekNr)
        {
            TimeSpan timespan = (endDate.Date.Subtract(startDate.Date));
            double days = timespan.TotalDays;                                // Får ut perioden mellan datumen i dagar


            List<string> ConferencePriceList = new List<string>();
            List<int> Price = new List<int>();
            List<int> Price1 = new List<int>();

            if (weekNr != 0 && days == 7 && startDate.DayOfWeek == DayOfWeek.Sunday && endDate.DayOfWeek == DayOfWeek.Sunday)// Ifall perioden är 7 dagar (1 vecka) samt startdatumet o slutdatumet är en söndag
            {                                                                                                                 // görs en sökning på veckornr o väljer priset för en hel vecka. 
                var search = from c in db.KonferensPris
                             where c.konferensTyp == "Lillbacken" && c.period == "vecka" && c.veckoNr == weekNr
                             select c.pris.ToString();

                var search1 = from c in db.KonferensPris
                              where c.konferensTyp == "Storbacken" && c.period == "vecka" && c.veckoNr == weekNr
                              select c.pris.ToString();

                ConferencePriceList.Add("Lillback" + "\t" + search.FirstOrDefault() + "\t" + weekNr + "\t" + startDate.ToShortDateString() + "\t" + endDate.ToShortDateString()); // Informationen som returneras till GUI:t
                ConferencePriceList.Add("Storback" + "\t" + search1.FirstOrDefault() + "\t" + weekNr + "\t" + startDate.ToShortDateString() + "\t" + endDate.ToShortDateString());
            
            }
            else if (startDate.DayOfWeek == DayOfWeek.Sunday && endDate.DayOfWeek == DayOfWeek.Sunday && days == 7)               //Samma utsökning som ovan dock gäller denna när man väljer vecka via två datum istället.                    
            {
                CultureInfo culture = CultureInfo.CurrentCulture;
                int weekNum = culture.Calendar.GetWeekOfYear(startDate, CalendarWeekRule.FirstFullWeek, DayOfWeek.Sunday);

                var search = from c in db.KonferensPris
                             where c.konferensTyp == "Lillbacken" && c.period == "vecka" && c.veckoNr == weekNr
                             select c.pris.ToString();

                var search1 = from c in db.KonferensPris
                              where c.konferensTyp == "Storbacken" && c.period == "vecka" && c.veckoNr == weekNr
                              select c.pris.ToString();

                ConferencePriceList.Add("Lillback" + "\t" + search.FirstOrDefault() + "\t" + weekNr + "\t" + startDate.ToShortDateString() + "\t" + endDate.ToShortDateString()); // Informationen som returneras till GUI:t
                ConferencePriceList.Add("Storback" + "\t" +  search1.FirstOrDefault() + "\t" + weekNr + "\t" + startDate.ToShortDateString() + "\t" + endDate.ToShortDateString());
            }

            else if (startDate.Date == endDate.Date)                                                                                   // Ifall startdatum är samma som slutdatum görs en utsökning på timmar för att få fram priset. 
            {
                TimeSpan timeSpanHours = (endDate.Subtract(startDate));
                double hours = timeSpanHours.TotalHours;

                CultureInfo culture = CultureInfo.CurrentCulture;
                int weekNum = culture.Calendar.GetWeekOfYear(startDate, CalendarWeekRule.FirstFullWeek, DayOfWeek.Sunday);

                DateTime countHours = startDate;
                while (countHours.AddHours(1) <= endDate)
                {
                    countHours = countHours.AddHours(1);
                    var search = (from c in db.KonferensPris
                                  where c.konferensTyp == "Lillbacken" && c.period == "tim" && c.veckoNr == weekNum
                                  select c).First<KonferensPri>().pris;
                    var search1 = (from c in db.KonferensPris
                                   where c.konferensTyp == "Storbacken" && c.period == "tim" && c.veckoNr == weekNr
                                   select c).First<KonferensPri>().pris;
                    Price.Add(search.Value);
                    Price1.Add(search1.Value);
                }
                ConferencePriceList.Add("Lillback" + "\t" + Price.Sum() + "\t" + weekNr + "\t" + startDate + "\t" + endDate);       // Informationen som returneras till GUI:t
                ConferencePriceList.Add("Storback" + "\t" + Price1.Sum() + "\t" + weekNr + "\t" + startDate + "\t" + endDate);

            }


            else
            {
                DateTime countDays = startDate;
                while (countDays.AddDays(1) <= endDate)
                {

                    countDays = countDays.AddDays(1);
                    CultureInfo culture = CultureInfo.CurrentCulture;
                    int weekNum = culture.Calendar.GetWeekOfYear(startDate, CalendarWeekRule.FirstFullWeek, DayOfWeek.Sunday);


                    var search = (from c in db.KonferensPris
                                  where c.konferensTyp == "Lillbacken" && c.period == "dygn" && c.veckoNr == weekNum
                                  select c).First<KonferensPri>().pris;
                    var search1 = (from c in db.KonferensPris
                                   where c.konferensTyp == "Storbacken" && c.period == "dygn" && c.veckoNr == weekNr
                                   select c).First<KonferensPri>().pris;
                    Price.Add(search.Value);
                    Price1.Add(search1.Value);
                }
                ConferencePriceList.Add("Lillback" + "\t" + Price.Sum() + "\t" + weekNr + "\t" + startDate.ToShortDateString() + "\t" + endDate.ToShortDateString());
                ConferencePriceList.Add("Storback" + "\t" + Price1.Sum() + "\t" + weekNr + "\t" + startDate.ToShortDateString() + "\t" + endDate.ToShortDateString());    // Informationen som returneras till GUI:t

            }


            return ConferencePriceList;
        }

        /// <summary>
        /// Hämtar ut antal lediga campingplatser efter angiven period. 
        /// </summary>
        /// <param name="startDate"></param>
        /// <param name="endDate"></param>
        /// <param name="weekNr"></param>
        /// <returns></returns>
        public List<string> GetCampFreeLodging(DateTime startDate, DateTime endDate, int weekNr)
        {
            TimeSpan timespan = (endDate.Subtract(startDate));
            double days = timespan.TotalDays;                     // Får ut perioden mellan datumen i dagar


            List<string> CampFreeList = new List<string>();
            List<int> Price = new List<int>();

            if (weekNr != 0 && days == 7 && startDate.DayOfWeek == DayOfWeek.Sunday && endDate.DayOfWeek == DayOfWeek.Sunday)     // Ifall perioden är 7 dagar (1 vecka) samt startdatumet o slutdatumet är en söndag
            {                                                                                                                       // görs en sökning på veckornr o väljer priset för en hel vecka.   
                var search = from lp in db.LogiPris
                             where lp.logiTyp == "Camp" && lp.period == "7" && lp.veckoNr == weekNr
                             select lp.pris.ToString();
              
                CampFreeList.Add("Camp" + "\t" + search.Single() + "\t" + weekNr + "\t" + startDate.ToShortDateString() + "\t" + endDate.ToShortDateString());
               
            }
            else
            {
                if (startDate.DayOfWeek == DayOfWeek.Sunday && endDate.DayOfWeek == DayOfWeek.Sunday && days == 7)
                {
                    CultureInfo culture = CultureInfo.CurrentCulture;
                    int weekNum = culture.Calendar.GetWeekOfYear(startDate, CalendarWeekRule.FirstFullWeek, DayOfWeek.Sunday);

                    var search = from lp in db.LogiPris
                                 where lp.logiTyp == "Camp" && lp.period == "7" && lp.veckoNr == weekNum
                                 select lp.pris.ToString();
                    CampFreeList.Add("Camp" + "\t" + search.Single() + "\t" + weekNr + "\t" + startDate.ToShortDateString() + "\t" + endDate.ToShortDateString());
                }
                else
                {
                    DateTime countDays = startDate;
                    while (countDays.AddDays(1) <= endDate)
                    {

                        CultureInfo culture = CultureInfo.CurrentCulture;
                        int weekNum = culture.Calendar.GetWeekOfYear(startDate, CalendarWeekRule.FirstFullWeek, DayOfWeek.Sunday);
                        countDays = countDays.AddDays(1);
                        var search = (from lp in db.LogiPris
                                      where lp.logiTyp == "Camp" && lp.period == "1" && lp.veckoNr == weekNum
                                      select lp).First<LogiPri>().pris;

                        Price.Add(search.Value);
                    }
                }
                CampFreeList.Add("Camp" + "\t"  + Price.Sum() + "\t" + weekNr + "\t" + startDate.ToShortDateString() + "\t" + endDate.ToShortDateString());
            }

            return CampFreeList;
        }
        /// <summary>
        /// Söker efter antal lediga logier och returnerar logiTyp och Antal
        /// </summary>
        /// <param name="s"></param>
        /// <param name="sl"></param>
        /// <param name="veckoNr"></param>
        /// <param name="antalDagar"></param>
        /// <returns></returns>
        public List<string> GetApartmentFreeLodging(DateTime s, DateTime sl, string veckoNr, string antalDagar)
        {
            var tillgänglig = from l in db.Logis                            //Filtrerar ut bokade o reserverade logier med de angivna datumen. 
                              where !(from r in db.LBokningsRads            // Här filtreras alla logier från tabellen Logibokningsrad.                       
                                      where s >= r.frånDatum && sl <= r.tillDatum ||
                                            s <= r.frånDatum && sl >= r.tillDatum
                                      select r.logiID).Contains(l.logiID)
                              where !(from re in db.Reservations            // Här filtreras alla logier från reservationstabellen.
                                     join lo in db.Logis on re.logiID equals lo.logiID
                                      where s >= re.startTid && sl <= re.slutTid ||
                                     s <= re.startTid && sl >= re.slutTid 
                                     select re.logiID).Contains(l.logiID)

                              group l by l.logiTyp into lr                  // Grupperar utsökningen på logityp
                              select new { Typ = lr.Key.ToString(), Antal = lr.Count().ToString()  }; 

            List<string> logi = new List<string>();
            foreach (var v in tillgänglig)
            {
                logi.Add(v.Typ +"\t" + v.Antal + "st");                     // matar in utsökningen i listan "logi" som returneras till gui:t.
            }            
            return logi;
        }
        /// <summary>
        /// Hämtar ut ledigt konferensID när man reserverar en konferens.
        /// </summary>
        /// <param name="startDate"></param>
        /// <param name="endDate"></param>
        /// <param name="lodgingType"></param>
        /// <returns></returns>
        public List<string> FreeConferenceID(DateTime startDate, DateTime endDate, string lodgingType) 
        {
            var tillgänglig = from k in db.Konferens
                              where k.konferensTyp == lodgingType
                              where !(from kr in db.KBokningsRads           // Filtrerar ut bokade konferensID:n från konferensbokningsrad under den angivna perioden.
                                      where startDate >= kr.frånDatum && endDate <= kr.tillDatum || startDate <= kr.frånDatum && endDate >= kr.tillDatum
                                      select kr.konferensID).Contains(k.konferensID)
                              where !(from re in db.ReservationKonferens    // Filtrerar ut bokade konferensID:n från reservationkonferens-tabellen under den angivna perioden.
                                      join ko in db.Konferens on re.konferensID equals ko.konferensID
                                      where startDate >= re.startTid && endDate <= re.slutTid || startDate <= re.startTid && endDate >= re.slutTid
                                      select re.konferensID).Contains(k.konferensID)
                              group k by k.konferensID into lr              
                              select new { LogiID = lr.Key.ToString() };

            List<string> confID = new List<string>();
            foreach (var v in tillgänglig)
            {
                confID.Add(v.LogiID);            
            }
            return confID.ToList<string>();
        }
        /// <summary>
        ///  Hämtar ut ledigt logiID när man reserverar logi.
        /// </summary>
        /// <param name="startDate"></param>
        /// <param name="endDate"></param>
        /// <param name="lodgingType"></param>
        /// <returns></returns>
        public List<string> FreeLodgingID(DateTime startDate, DateTime endDate,string lodgingType)
        {
            var tillgänglig = from l in db.Logis
                              where l.logiTyp == lodgingType
                              where !(from r in db.LBokningsRads            // Filtrerar ut bokade logiID:n från logibokningsrad under den angivna perioden.
                                      where startDate >= r.frånDatum && endDate <= r.tillDatum ||
                                      startDate <= r.frånDatum && endDate >= r.tillDatum
                                      select r.logiID).Contains(l.logiID)
                              where !(from re in db.Reservations            // Filtrerar ut bokade logiID:n från logiboknings under den angivna perioden.
                                      join lo in db.Logis on re.logiID equals lo.logiID
                                      where startDate >= re.startTid && endDate <= re.slutTid ||
                                      startDate <= re.startTid && endDate >= re.slutTid 
                                      select re.logiID).Contains(l.logiID)
                            
                              group l by l.logiID into lr
                              select new { LogiID = lr.Key.ToString() };

            List<string> logiID = new List<string>();
            foreach (var v in tillgänglig)
            {
                logiID.Add(v.LogiID);
            }
            return logiID.ToList<string>();
            
            
        }   
     
        /// <summary>
        /// Hämtar priset för  LGH I och LGH II för en specifik period.
        /// </summary>
        /// <param name="weekNr"></param>
        /// <param name="period"></param>
        /// <returns></returns>
        public IQueryable GetPrice (int weekNr, string period) 
        {
            var pris = from p in db.LogiPris                     
                       where p.veckoNr == weekNr && p.logiTyp != "Camp" && p.period == period
                       select p;                       
            return pris;
        }

        // Hämtar ut prisalternativen för en specifik logi och period. Denna metoden används vid administration. 
        public IQueryable GetLodgingPrice(string tempType, int tempWeek)
        {
            var search = from lp in db.LogiPris
                         where lp.logiTyp == tempType && lp.veckoNr == tempWeek
                         select lp;
            return search;
        }

        /// <summary>
        /// Tar in nödvändig attribut och skapar en bokning i databasen.
        /// </summary>
        /// <returns>Returnerar en Bokning</returns>
        public void CreateBooking(int gästNr, int personalID, bool avbokningsskydd, int discount, int totSum)
        {
            Bokning bokning = new Bokning(); // Skapar ny boking. 
        
                    bokning.gästNr = gästNr;
                    bokning.personalID = personalID;
                    bokning.avbokningsskydd = avbokningsskydd;
                    bokning.rabatt = discount;
                    bokning.totSum = totSum;

                    db.Boknings.InsertOnSubmit(bokning);
                    db.SubmitChanges();
        }       
        
        /// <summary>
        /// Tar in ett objekt av typen Logi och lägger till en bokningsrad i databasen.
        /// </summary>
        public void PutInBookingRow(string lodgingId, int bookingID, DateTime starDate, DateTime stopDate, int price, int weekNr)
        {
            KBokningsRad conferenceBookingRow = new KBokningsRad();
            LBokningsRad lodgingBookingRow = new LBokningsRad();

            if (lodgingId[1] == 'i' || lodgingId[1] == 't') // ifall index[1] är i eller t så är det en konferens o då skapas det en ny bokningsrad för konferens.
                    {


                        conferenceBookingRow.konferensID = lodgingId;
                        conferenceBookingRow.bokningsNr = bookingID;

                        conferenceBookingRow.frånDatum = starDate;
                        conferenceBookingRow.tillDatum = stopDate;
                        conferenceBookingRow.pris = price;
                        conferenceBookingRow.veckoNr = weekNr;

                        db.KBokningsRads.InsertOnSubmit(conferenceBookingRow);
                        db.SubmitChanges();

                    }
            else          // ifall det inte är konferens är det logi o då skapas det en ny bokningsrad för logi.                       
           
                    {

                        lodgingBookingRow.logiID = lodgingId;
                        lodgingBookingRow.bokningsNr = bookingID;

                        lodgingBookingRow.frånDatum = starDate;
                        lodgingBookingRow.tillDatum = stopDate;
                        lodgingBookingRow.pris = price;
                        lodgingBookingRow.veckoNr = weekNr;

                        db.LBokningsRads.InsertOnSubmit(lodgingBookingRow);
                        db.SubmitChanges();
                    }                
            }
        /// <summary>
        /// Uppdaterar en befintlig bokningsrad vid ändring av bokning eller när man lägger till nya bokningar i en befintlig bokning. 
        /// </summary>
        /// <param name="bookingID"></param>
        /// <param name="cancelProtection"></param>
        /// <param name="price"></param>
        public void BookingRowUpdate(int bookingID, bool cancelProtection, int price)
        {
            var booking = from b in db.Boknings
                          where b.bokningsNr == bookingID
                          select b;
            foreach (Bokning b in booking)              //Uppdaterar bokningsraden
            {
                b.avbokningsskydd = cancelProtection;
             
                b.totSum =b.totSum + price;
            }
            var invoice = from i in db.Fakturas      
                          where i.bokningsNr == bookingID
                          select i;
            foreach (Faktura i in invoice)              // Uppdaterar fakturan
            {
                i.totalSumma = i.totalSumma + price;
            }

            db.SubmitChanges();
                
        }
        /// <summary>
        /// Uppdaterar en befintlig uthyrningsrad när man lägger till nya uthyrningar i en befintlig uthyrning. (Lägger till uthyrningsrader i uthyrning)
        /// </summary>
        /// <param name="tTempRentalID"></param>
        /// <param name="price"></param>
        public void RentalRowUpdate(int tTempRentalID, int price)
        {
            var rental = from r in db.Uthyrnings
                         join f in db.Fakturas on r.gästNr equals f.gästNr
                         where f.gästNr == r.gästNr && f.fakturaTyp == "c" && r.uthyrningsNr == f.uthyrningsNr // Utsökningen o villkoren för att hitta rätt uthyrning. 
                         select r;
            foreach (Uthyrning r in rental) // Uppdaterar uthyrningen
            {

                r.pris = r.pris + price;
            }
            var invoice = from i in db.Fakturas
                          join r in db.Uthyrnings on i.gästNr equals r.gästNr
                          where i.gästNr == r.gästNr && i.fakturaTyp == "c" && i.uthyrningsNr == r.uthyrningsNr  // Utsökningen o villkoren för att hitta rätt faktura. 
                          select i;
            foreach (Faktura i in invoice) // Uppdaterar fakturan 
            {
                
                i.totalSumma = i.totalSumma + price;
                i.uthyrningsNr = tTempRentalID;
            }

            db.SubmitChanges();

        }
        /// <summary>
        /// Metoden använd när man lägger till en uthyrning i en existerande faktura, den uppdaterar fakturasumman o lägger till uthyrningsnumret i fakturan. 
        /// </summary>
        /// <param name="tTempRentalID"></param>
        /// <param name="price"></param>
       public void LinkRentalRowWithInvoice(int tTempRentalID, int price)
        {
            var rental = from r in db.Uthyrnings
                         join f in db.Fakturas on r.gästNr equals f.gästNr
                         where f.gästNr == r.gästNr && f.fakturaTyp == "c" && r.uthyrningsNr == f.uthyrningsNr
                         select r;
            foreach (Uthyrning r in rental)
            {
                r.pris = price;
            }
            var invoice = from i in db.Fakturas
                          join r in db.Uthyrnings on i.gästNr equals r.gästNr
                          where i.gästNr == r.gästNr && i.fakturaTyp == "c" && i.uthyrningsNr == r.uthyrningsNr  
                          select i;
            foreach (Faktura i in invoice)
            {

                i.totalSumma = price;
                i.uthyrningsNr = tTempRentalID;
            }

            db.SubmitChanges();

        }

        /// <summary>
        /// Uppdaterar en gästs kreditgräns efter en bokning är gjord. 
        /// </summary>
        /// <param name="newCredit"></param>
        /// <param name="guestNr"></param>
        public void CreditUpdate(int newCredit, int guestNr)
        {
            var credit = from g in db.Gästs
                         where g.gästNr == guestNr
                         select g;                         
            
            foreach (Gäst g in credit)
            {
                g.kreditgräns = newCredit;
            }
            db.SubmitChanges();
        }     
        
        /// <summary>
        /// Gör en utsökning i databasen och returnerar det senaste skapade bokningsnumret. 
        /// </summary>
        /// <returns>Returnerar en int</returns>
        public int GetBookingNumber()
        {
            var bnumber = (from b in db.Boknings
                           select b.bokningsNr).Max();

            return bnumber;
        }
        /// <summary>
        /// Gör en utsökning i databasen och returnerar det senaste skapade gästnumret. 
        /// </summary>
        /// <returns></returns>
        public int GetGuestNr()
        {
            var gnumber = (from g in db.Gästs
                           select g.gästNr).Max();
            return gnumber;
        }

        /// <summary>
        /// Reserverar en logi/konferens när gästen har bestämt sig. Reservationen läggs till i reservationsrutan och när den väl är där kan ingen annan boka den förräns man tar bort reservationen. 
        /// </summary>
        /// <param name="lodging">Lodging to be reserved.</param>
        /// <param name="startTime">Start time.</param>
        /// <param name="stopTime">Stop time.</param>
        public void ReserveLodging(string lodging, DateTime startTime, DateTime stopTime)
        {
            ReservationKonferen newConferenceReservation = new ReservationKonferen(); //  Här skapas en ny konference- o logireservation
            Reservation newLodgingReservation = new Reservation();

            try
            {
                using (TransactionScope scope = new TransactionScope())
                {
                    if (lodging[1] == 'i' || lodging[1] == 't')  // Ifall index[1] i lodgingtypen är "i" eller "t" betyder det att det är konferens (l(i)llbacken/s(t)orbacken)
                    {                                           // ifall det är en konferens som ska reserveras läggs nyckelattributen in i en reservationsrad i databasen.
                        
                        newConferenceReservation.konferensID = lodging;
                        newConferenceReservation.startTid = startTime;
                        newConferenceReservation.slutTid = stopTime;
                        db.ReservationKonferens.InsertOnSubmit(newConferenceReservation);
                        db.SubmitChanges();
                    }
                    else
                    {                                            // ifall det är en logi som ska reserveras läggs nyckelattributen in i en reservationsrad i databasen.

                        newLodgingReservation.logiID = lodging;
                        newLodgingReservation.startTid = startTime;
                        newLodgingReservation.slutTid = stopTime;
                        db.Reservations.InsertOnSubmit(newLodgingReservation);
                        db.SubmitChanges();                
                    }

                    scope.Complete();
                }

            }
            catch                                                     // Om  det inte skulle gå raderar den reservationsraden. 
            {
                db.ReservationKonferens.DeleteOnSubmit(newConferenceReservation);
                db.Reservations.DeleteOnSubmit(newLodgingReservation);
            }
        }

        /// <summary>
        ///Släpper den temporära reservationen för en specifik logi-/konferensreservation.
        /// </summary>
        /// <param name="lodging">The lodging.</param>
        /// <param name="startTime">Start time</param>
        /// <param name="stopTime">Stop time</param>
        public void DropReservedLodging(string lodging, DateTime startTime, DateTime stopTime)
        {
            if (lodging[1] == 'i' || lodging[1] == 't') // Ifall det är en konferens så raderar den reservationsraden. 
            {
                var query = db.ReservationKonferens.SingleOrDefault(l => l.konferensID == lodging && (l.startTid == startTime && l.slutTid == stopTime));
                db.ReservationKonferens.DeleteOnSubmit(query);
            }
            else
            {                                           // Här raderas reservationsraden för logi. 
                var query = db.Reservations.SingleOrDefault(l => l.logiID == lodging && (l.startTid == startTime && l.slutTid == stopTime));
                db.Reservations.DeleteOnSubmit(query);
            }
            db.SubmitChanges();
        }
        /// <summary>
        /// Tar bort en bokning från databasen med angiven bokningsnr
        /// </summary>
        /// <param name="bokningsNr"></param>
        public void DropBookingLodging(int bokningsNr)
        {            
            var query = db.Boknings.SingleOrDefault(b => b.bokningsNr == bokningsNr);
            db.Boknings.DeleteOnSubmit(query);
            db.SubmitChanges();
        }
        /// <summary>
        /// Ändrar priset för en specifik logityp för den veckan o perioden. 
        /// </summary>
        /// <param name="tempType"></param>
        /// <param name="tempWeek"></param>
        /// <param name="tempPeriod"></param>
        /// <param name="tempPrice"></param>
        public void ChangedLodgPrice(string tempType, int tempWeek, string tempPeriod, int tempPrice)
        {
            var search = from lp in db.LogiPris
                         where lp.logiTyp == tempType && lp.veckoNr == tempWeek && lp.period == tempPeriod
                         select lp;

            foreach (LogiPri lp in search)
            {
                lp.pris = tempPrice;
            }

            db.SubmitChanges();
        }

        #endregion
        //************************************************************ Konferenshantering ******************************************************//
        #region
        /// <summary>
        /// Hämtar konferenspris för en viss typ av konferensrum och vecka
        /// </summary>
        /// <param name="tempId"></param>
        /// <param name="tempWeek"></param>
        /// <returns></returns>
        public IQueryable GetConferencePrice(string tempId, int tempWeek)
        {
            var search = from cp in db.KonferensPris
                         where cp.konferensTyp == tempId && cp.veckoNr == tempWeek
                         select cp;
            return search;
        }

        /// <summary>
        /// Ändrar konferenspris för en viss typ av konferens med specifik period och vecka
        /// </summary>
        /// <param name="tempType"></param>
        /// <param name="tempWeek"></param>
        /// <param name="tempPeriod"></param>
        /// <param name="tempPrice"></param>
        public void ChangedConfPrice(string tempType, int tempWeek, string tempPeriod, int tempPrice)
        {
            var search = from cp in db.KonferensPris
                         where cp.konferensTyp == tempType && cp.veckoNr == tempWeek && cp.period == tempPeriod
                         select cp;

            foreach (KonferensPri cp in search)
            {
                cp.pris = tempPrice;
            }

            db.SubmitChanges();
        }

        #endregion

        //***************************************************** Bokningshantering (visa, redigera) *********************************************//
        #region
        /// <summary>
        /// Hämtar företagsgästs bokningar på gästnr
        /// </summary>
        /// <param name="tempCoGuestId">GästNr</param>
        /// <returns></returns>
        public IQueryable GetBookingByCoGuestId(int tempCoGuestId)
        {
            var search = (from g in db.Gästs
                          join b in db.Boknings on g.gästNr equals b.gästNr
                          where g.gästNr == tempCoGuestId
                          select b.bokningsNr + " " + g.gästNr + " " + g.företagsNamn);
            return search;
        }

        /// <summary>
        /// Hämtar privatgästs bokningar på gästnr
        /// </summary>
        /// <param name="tempPrGuestId">GästNr</param>
        /// <returns></returns>
        public IQueryable GetBookingByPrGuestId(int tempPrGuestId)
        {
            var search = (from g in db.Gästs
                          join b in db.Boknings on g.gästNr equals b.gästNr
                          where g.gästNr == tempPrGuestId
                          select b.bokningsNr + " " + g.gästNr + " " + g.förNamn + " " + g.efterNamn);
            return search;
        }


        /// <summary>
        /// Hämtar bokning på bokningsnummer vid sökning på privatgäst
        /// </summary>
        /// <param name="tempId">BokningsNr</param>
        /// <returns></returns>
        public IQueryable GetBookingById(int tempId)
        {                    
            var search = from b in db.Boknings
                            join g in db.Gästs on b.gästNr equals g.gästNr
                            where b.bokningsNr == tempId
                            select b.bokningsNr + " " + b.gästNr + " " + g.förNamn + " " + g.efterNamn;

            return search;                                
        }
        /// <summary>
        /// Hämtar bokningar genom gästnamnet. 
        /// </summary>
        /// <param name="tempName"></param>
        /// <returns></returns>
        public IQueryable GetBookingByName(string tempName)
        {
            var search = from g in db.Gästs
                         join b in db.Boknings on g.gästNr equals b.gästNr
                         where g.förNamn.StartsWith(tempName) || g.efterNamn.StartsWith(tempName) || g.förNamn.EndsWith(tempName) || g.efterNamn.EndsWith(tempName) || g.förNamn + g.efterNamn == tempName
                         select b.bokningsNr + " " + g.gästNr + " " + g.förNamn + " " + g.efterNamn;
            return search;
        }

        /// <summary>
        /// Hämtar bokning på bokningsnummer vid sökning på företagsgäst
        /// </summary>
        /// <param name="tempId">Bokningsnr</param>
        /// <returns></returns>
        public IQueryable GetBookingByIdCompany(int tempId)
        {
            var search = from b in db.Boknings
                         join g in db.Gästs on b.gästNr equals g.gästNr
                         where b.bokningsNr == tempId
                         select b.bokningsNr + " " + b.gästNr + " "  + g.företagsNamn;
            return search;
        }

        /// <summary>
        /// Hämtar bokningar på företagsnamn
        /// </summary>
        /// <param name="tempCoName">Företagsnamn</param>
        /// <returns></returns>
        public IQueryable GetBookingByCompanyName(string tempCoName)
        {
            var search = from g in db.Gästs
                         join b in db.Boknings on g.gästNr equals b.gästNr
                         where g.företagsNamn.StartsWith(tempCoName) || g.företagsNamn.EndsWith(tempCoName)
                         select b.bokningsNr + " " + g.gästNr + " " + g.företagsNamn;
            return search;
        }

        /// <summary>
        /// Hämtar bokningsrader på specifikt bokningsnummer
        /// </summary>
        /// <param name="tempBookingId">BokningsNr</param>
        /// <returns></returns>
        public List<string> GetBookingRow(int tempBookingId)
        {
            List<string> bookingRows = new List<string>();
            var search = from lb in db.LBokningsRads
                         join l in db.Logis on lb.logiID equals l.logiID
                         where lb.bokningsNr == tempBookingId
                         select new
                         {
                             bokningsnr = lb.bokningsNr,
                             logiID = lb.logiID,
                             frånDatum = lb.frånDatum,
                             tillDatum = lb.tillDatum,
                             logityp = l.logiTyp,
                             pris = lb.pris,
                             vecka = lb.veckoNr
                             
                         };
            foreach (var lb in search)
            {
                bookingRows.Add(lb.logiID + "\t" + lb.logityp + "\t" + lb.pris + "\t" + lb.vecka + "\t" + lb.frånDatum.ToShortDateString() + "\t" + lb.tillDatum.ToShortDateString());
            }
            return bookingRows;
        }

        #endregion
        //************************************************************* Gästhistorik ***********************************************************//
        #region
        /// <summary>
        /// laddar in gästens historik för logi
        /// </summary>
        /// <param name="tempGuestID"></param>
        /// <returns></returns>
        public List<string> GetGuestHirstory(int tempGuestID) 
        {
           
            var history = (from b in db.Boknings
                          
                           join lb in db.LBokningsRads on b.bokningsNr equals lb.bokningsNr
                          
                          where b.gästNr == tempGuestID

                           select "ID: " + lb.logiID + " Från: " + lb.frånDatum + "\t Till: " + lb.tillDatum); //history; 
           
            return history.ToList<string>();
        }
        /// <summary>
        /// laddar in gästens historik för konferens
        /// </summary>
        /// <param name="tempGuestID"></param>
        /// <returns></returns>
        public List<string> GetGuestHistoryConferens(int tempGuestID)
        {
            var historyConferens = (from b in db.Boknings
                                    join kb in db.KBokningsRads on b.bokningsNr equals kb.bokningsNr
                                    where b.gästNr == tempGuestID
                                    select "ID: " + kb.konferensID + " Från: " + kb.frånDatum + " Till: " + kb.tillDatum);
            return historyConferens.ToList<string>();

        }

        #endregion
        //********************************************************* Utrustningshantering *******************************************************//
        #region
        /// <summary>
        /// Hämtar utrustning för visning i administrations gui. 
        /// </summary>
        /// <param name="tempType"></param>
        /// <returns></returns>
        public IQueryable GetEquipment(string tempType)
        {
            var search = from u in db.UtrustningsPris
                         where u.utrustningsTyp == tempType
                         select u;
            return search;
        }

        /// <summary>
        /// Uppdaterar en viss utrustningstyps pris för en period
        /// </summary>
        /// <param name="tempType">Utrustningstyp</param>
        /// <param name="tempPeriod">Period</param>
        /// <param name="tempPrice">Nytt pris</param>
        public void ChangedEquipPrice(string tempType, string tempPeriod, int tempPrice)
        {
            var search = from u in db.UtrustningsPris
                         where u.utrustningsTyp == tempType && u.antalDagar == tempPeriod
                         select u;

            foreach (UtrustningsPri u in search)
            {
                u.pris = tempPrice;
            }

            db.SubmitChanges();
        }

        /// <summary>
        /// Hämtar utrustning på specifikt ID
        /// </summary>
        /// <param name="tempId">UtrustningsId</param>
        /// <returns></returns>
        public List<string> GetEqById(string tempId)
        {
            var search = (from e in db.Utrustnings
                          where e.utrustningsID == tempId
                          select e.utrustningsID + "   " + e.utrustningsTyp);
            return search.ToList<string>();
        }

        public List<string> GetEquipmentTypes()
        {
            var search = (from et in db.UtrustningsTyps
                          select et.utrustningsTyp1);
            return search.ToList<string>();
        }

        /// <summary>
        /// Hämtar utrustningspris på specifikt ID
        /// </summary>
        /// <param name="tempId"></param>
        /// <param name="nrDays"></param>
        /// <returns></returns>
        public List<string> GetEqPriceById(string tempId, string nrDays)
        {
            var search = (from e in db.Utrustnings
                          join ep in db.UtrustningsPris on e.utrustningsTyp equals ep.utrustningsTyp
                          where e.utrustningsID == tempId && ep.antalDagar == nrDays
                          select ep.pris.ToString());
            return search.ToList<string>();
        }

        /// <summary>
        /// Hämtar utrustningspris på specifikt paket
        /// </summary>
        /// <param name="temp"></param>
        /// <param name="nrDays"></param>
        /// <returns></returns>
        public List<string> GetEqPriceByPack(string temp, string nrDays)
        {
            var search = (from ep in db.UtrustningsPris
                          where ep.utrustningsTyp == temp && ep.antalDagar == nrDays
                          select ep.pris.ToString());
            return search.ToList<string>();
        }

        /// <summary>
        /// Kollar om valt utrustningsID finns i databasen
        /// </summary>
        /// <param name="tempId"></param>
        /// <returns></returns>
        public bool CheckEqInputById(string tempId)
        {
            var search = (from e in db.Utrustnings
                          where e.utrustningsID == tempId
                          select e.utrustningsID).Count();

            if (search == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        #endregion
        //***************************************************************Uthyrning**************************************************************//
        #region
        /// <summary>
        /// Skapar en ny uthyrning för företagsgäst
        /// </summary>
        /// <param name="gästNr"></param>
        /// <param name="staffId"></param>
        /// <param name="name"></param>
        /// <param name="address"></param>
        /// <param name="zip"></param>
        /// <param name="city"></param>
        /// <param name="price"></param>
        public void NewRentalCompany(int gästNr, int staffId, string name, string address, string zip, string city, int price)
        {
            Uthyrning newRental = new Uthyrning(); 

            newRental.gästNr = gästNr;
            newRental.personalID = staffId;
            newRental.namn = name;
            newRental.gatuadress = address;
            newRental.postNr = zip;
            newRental.ort = city;
            newRental.pris = price;

            db.Uthyrnings.InsertOnSubmit(newRental);
            db.SubmitChanges();
        }
        /// <summary>
        /// Skapar en ny uthyrning för privatgäster
        /// </summary>
        /// <param name="staffId"></param>
        /// <param name="name"></param>
        /// <param name="address"></param>
        /// <param name="zip"></param>
        /// <param name="city"></param>
        /// <param name="price"></param>
        public void NewRentalPrivate(int staffId, string name, string address, string zip, string city, int price)
        {
            Uthyrning newRental = new Uthyrning(); 

            newRental.personalID = staffId;
            newRental.namn = name;
            newRental.gatuadress = address;
            newRental.postNr = zip;
            newRental.ort = city;
            newRental.pris = price;

            db.Uthyrnings.InsertOnSubmit(newRental);
            db.SubmitChanges();
        }
        /// <summary>
        /// Skapar ny uthyrningsrad för en uthyrning
        /// </summary>
        /// <param name="rentalId"></param>
        /// <param name="eqId"></param>
        /// <param name="period"></param>
        /// <param name="price"></param>
        public void NewRentalRow(int rentalId, string eqId, string period, int price)
        {
            UthyrningsRad newRentalRow = new UthyrningsRad(); 

            double days = double.Parse(period);

            newRentalRow.uthyrningsNr = rentalId;
            newRentalRow.utrustningsID = eqId;
            newRentalRow.period = period;
            newRentalRow.pris = price;
            newRentalRow.startdatum = DateTime.Now;
            newRentalRow.slutdatum = DateTime.Now.AddDays(days-1);
            newRentalRow.återlämnat = false;

            db.UthyrningsRads.InsertOnSubmit(newRentalRow);
            db.SubmitChanges();
        }
        /// <summary>
        /// Hämtar senaste uthyrningsnumret för faktura.
        /// </summary>
        /// <returns></returns>
        public int GetRentalNumber()
        {
            var search = (from r in db.Uthyrnings
                          select r.uthyrningsNr).Max();
            return search;
        }
        
        /// <summary>
        /// Hämtar alla uthyrningsdetaljer för uthyrnings- o inlämningskvitton.
        /// </summary>
        /// <param name="rentNr"></param>
        /// <returns></returns>
        public List<string> GetRentalReceiptDetails(int rentNr)
        {
            List<string> RentalDetails = new List<string>();
            var search = from u in db.Uthyrnings
                         join ur in db.UthyrningsRads on u.uthyrningsNr equals ur.uthyrningsNr
                         where u.uthyrningsNr == rentNr
                         select new
                         {
                             rentNr = u.uthyrningsNr,
                             guestName = u.namn,
                             totPrice = u.pris
                         };
            
            foreach (var u in search)
            {
                RentalDetails.Add(u.rentNr + "\t" + u.guestName + "\t" + u.totPrice);
            }
            return RentalDetails;
        }
        /// <summary>
        /// Hämtar uthyrningsraderna för uthyrningskvittot. 
        /// </summary>
        /// <param name="rentNr"></param>
        /// <returns></returns>
        public List<string> GetRentalRow(int rentNr)
        {
            List<string> rentalRow = new List<string>();

            var search = from u in db.UthyrningsRads                       
                          where u.uthyrningsNr == rentNr
                          select new
                          {
                              equipId = u.utrustningsID,
                              startDate = u.startdatum.Value.ToShortDateString(),
                              returnDate = u.slutdatum.Value.ToShortDateString()
                          };

            foreach (var u in search)
            {                
                    rentalRow.Add("Id: " + " " + u.equipId + "    " + "\t" +  u.startDate + "\t" + u.returnDate);                
            }
            return rentalRow;
        }

        /// <summary>
        /// Hämtar senaste uthyrningsnumret för uthyrningskvittot. 
        /// </summary>
        /// <param name="rentNr"></param>
        /// <returns></returns>
        public IQueryable GetRentalByLastNumber(int rentNr)
        {
            var search = from u in db.Uthyrnings
                         where u.uthyrningsNr == rentNr
                         select u;
            return search;
        }
        #endregion
        //************************************************************** Återlämning************************************************************//
        #region
        /// <summary>
        /// Hämtar uthyrningsraderna för det specifika uthyrningsnumret. 
        /// </summary>
        /// <param name="tempId"></param>
        /// <returns></returns>
        public IQueryable GetRentalRowsById(int tempId)
        {
            var search = from ur in db.UthyrningsRads
                         where ur.uthyrningsNr == tempId && ur.återlämnat == false
                         select ur.uthyrningsNr + " \t" + ur.utrustningsID + "\t " + ur.slutdatum;
            return search;
        }
        /// <summary>
        /// Ändrar utrustningens återlämnings status vid lämning med specifik uthyrningsnr och utrustningsID
        /// </summary>
        /// <param name="tempNr"></param>
        /// <param name="tempId"></param>
        public void ReturnedEquip(int tempNr, string tempId)
        {
            var search = from ur in db.UthyrningsRads
                         where ur.uthyrningsNr == tempNr && ur.utrustningsID == tempId
                         select ur;

            foreach (UthyrningsRad ur in search)
            {
                ur.återlämnat = true;
            }

            db.SubmitChanges();             
        }
        /// <summary>
        /// Hämtar alla uthyrningsrader o gästnamnen för uthyrningarna som ska lämnas in idag och de som är försenade.
        /// </summary>
        /// <returns></returns>
        public IQueryable EquipIDLeftToReturn()
        {
            DateTime today = System.DateTime.Now.Date;
            var search = from ur in db.UthyrningsRads
                         join ut in db.Uthyrnings on ur.uthyrningsNr equals ut.uthyrningsNr
                         where ur.slutdatum <= today && ur.återlämnat == false
                         group ur by ut.uthyrningsNr + "\t" + ut.namn into result
                         select result.Key.ToString();

        
            return search;
        }
        /// <summary>
        /// Visar vilka utrustningsID:n som är kvar för en specifik uthyrning för återlämning.
        /// </summary>
        /// <param name="rentalID"></param>
        /// <returns></returns>
        public IQueryable EquipLeftToReturn(int rentalID)
        {
            DateTime today = System.DateTime.Now.Date;

            var search = from ur in db.UthyrningsRads
                         join ut in db.Uthyrnings on ur.uthyrningsNr equals ut.uthyrningsNr
                         where ur.slutdatum == today && ur.återlämnat == false && ur.uthyrningsNr == rentalID
                         select ur.uthyrningsNr + " \t" + ur.utrustningsID + "\t " + ur.slutdatum;
                         
            return search;
        }

        /// <summary>
        /// Hämtar specifik uthyrning på gästens namn.
        /// </summary>
        /// <param name="tempName"></param>
        /// <returns></returns>
        public IQueryable GetRentalsByName(string tempName)
        {
            var search = from u in db.Uthyrnings
                         join ur in db.UthyrningsRads on u.uthyrningsNr equals ur.uthyrningsNr
                         where (u.namn.EndsWith(tempName) || u.namn.StartsWith(tempName)) && ur.återlämnat == false
                         group u by u.uthyrningsNr into result
                         select result.FirstOrDefault();
            return search;
        }
        /// <summary>
        /// Hämtar utrustningsrader som är återlämnade för det specifika uthyrningsrumet. (För återlämningskvittot.)
        /// </summary>
        /// <param name="rentNr"></param>
        /// <returns></returns>
        public List<string> GetRentalRowReturned(int rentNr)
        {
            List<string> rentalRow = new List<string>();

            var search = from u in db.UthyrningsRads
                         where u.uthyrningsNr == rentNr && u.återlämnat == true
                         select new
                         {
                             equipId = u.utrustningsID,
                             startDate = u.startdatum.Value.ToShortDateString(),
                             returnDate = u.slutdatum.Value.ToShortDateString()
                         };

            foreach (var u in search)
            {
                rentalRow.Add("Id: " + " " + u.equipId + "     " + "\t" + u.startDate + "\t" + u.returnDate);
            }
            return rentalRow;
        }
        #endregion
        //************************************************************** Skidlektioner *********************************************************//
        #region
        /// <summary>
        /// Hämtar skidlektionsraderna för perioden Mån-Ons
        /// </summary>
        /// <returns></returns>
        public IQueryable GetSkiGroupLessonShort()
        {
            var search = from gl in db.GruppLektions
                         where gl.period == "Mån-Ons"
                         select "ID: " + gl.gruppLekID + "   " + gl.gruppTyp + "\tPris: " + gl.pris;
            return search;
        }
        /// <summary>
        /// Hämtar skidlektionsraderna för perioden Mån-fre
        /// </summary>
        /// <returns></returns>
        public IQueryable GetSkiGroupLessonLong()
        {
            var search = from gl in db.GruppLektions
                         where gl.period == "Mån-Fre"
                         select "ID: " + gl.gruppLekID + "   " + gl.gruppTyp + "\tPris: " + gl.pris;
            return search;
        }
        /// <summary>
        /// Hämtar skidlektionsraderna för privatlektion
        /// </summary>
        /// <param name="day"></param>
        /// <returns></returns>
        public IQueryable GetSkiLessonPrivate(string day)
        {
            var search = from pl in db.Privatlektions
                         where pl.dag == day
                         select "ID: " + pl.privatLekID + "    " + "Kl: " + pl.tid + "\tPris: " + pl.pris;
            return search;
        }
        /// <summary>
        /// Hämtar deltagarna för grupplektionerna. 
        /// </summary>
        /// <param name="weekNr"></param>
        /// <returns></returns>
        public List<string> GetAttenders(int weekNr)
        {
            var search = (from gbr in db.GBokningsRads
                          where gbr.vecka == weekNr.ToString()
                          group gbr by gbr.gruppLekID into free
                          select new { type = free.Key.ToString(), nr = free.Count().ToString() });

            var search2 = (from gl in db.GruppLektions
                           group gl by gl.gruppLekID into all
                           select new { type = all.Key.ToString() });

            List<string> nrFree = new List<string>();
            int maxNr = GetMaxAttenders();
            for (int i = GetLessonIds().Min(); i <= GetLessonIds().Max(); i++)
            {
                int nr = 0;
                foreach (var l in search2)
                {
                    if (i == int.Parse(l.type))
                    {
                        foreach (var br in search)
                        {
                            if (i == int.Parse(br.type))
                            {
                                nr = int.Parse(br.nr);
                            }
                        }
                        nrFree.Add("ID: " + i + "   " + (maxNr - nr) + " st");
                    }
                }
            }
            return nrFree;
        }
        /// <summary>
        /// Hämtar deltagarna för privatlektionerna.
        /// </summary>
        /// <param name="day"></param>
        /// <param name="week"></param>
        /// <returns></returns>
        public List<string> GetPrivateAttenders(string day, int week)
        {
            var search = (from pbr in db.PBokningsRads
                          where pbr.vecka == week.ToString()
                          group pbr by pbr.privatLekID into free
                          select new { type = free.Key.ToString(), nr = free.Count().ToString() });

            var search2 = (from pl in db.Privatlektions
                           where pl.dag == day
                           group pl by pl.privatLekID into all
                           select new { type = all.Key.ToString() });

            List<string> priFree = new List<string>();

            for (int i = GetPriLessonIds().Min(); i <= GetPriLessonIds().Max(); i++)
            {
                string available = "Ledig";
                foreach (var l in search2)
                {
                    if (i == int.Parse(l.type))
                    {
                        foreach (var br in search)
                        {
                            if (i == int.Parse(br.type))
                            {
                                available = "Bokad!";
                            }
                        }
                        priFree.Add("ID: " + i + "   " + available);
                    }
                }
            }
            return priFree;
        }
        /// <summary>
        /// Hämtar ut namnen på eleverna för privatlektioner. 
        /// </summary>
        /// <param name="day"></param>
        /// <param name="week"></param>
        /// <returns></returns>
        public List<string> GetPrivateLessonNames(string day, string week)
        {
            List<string> lessonNames = new List<string>();
            var search = from p in db.Privatlektions
                         join pb in db.PBokningsRads on p.privatLekID equals pb.privatLekID
                         where p.dag == day && pb.vecka == week
                         select new { time = p.tid, name = pb.namn };
            foreach (var pb in search)
            {
                lessonNames.Add(pb.time + "\t" +  pb.name);
            }
            return lessonNames;            
        }
        /// <summary>
        /// Hämtar ut namnen på eleverna för grupplektioner. 
        /// </summary>
        /// <param name="week"></param>
        /// <param name="period"></param>
        /// <param name="groups"></param>
        /// <returns></returns>
        public List<string> GetGroupLessonNames(string week, string period, string groups)
        {
            List<string> lessonNames = new List<string>();
            var search = from g in db.GruppLektions
                         join gb in db.GBokningsRads on g.gruppLekID equals gb.gruppLekID
                         where gb.vecka == week && g.gruppTyp == groups && g.period == period
                         select new { name = gb.namn };
            foreach (var gb in search)
            {
                lessonNames.Add(gb.name);
            }
            return lessonNames;
        }
        /// <summary>
        /// Hämtar ut antalet av max antal deltagande. 
        /// </summary>
        /// <returns></returns>
        public int GetMaxAttenders()
        {
            var search = (from gl in db.GruppLektions
                          select gl.maxAntal).Max();
            return (int)search;
        }
        /// <summary>
        /// Hämtar ut lediga platser för grupplektioner
        /// </summary>
        /// <param name="id"></param>
        /// <param name="week"></param>
        /// <returns></returns>
        public int CheckAvailableGroup(int id, int week)
        {
            var search = (from gbr in db.GBokningsRads
                          where gbr.gruppLekID == id && gbr.vecka == week.ToString()
                          select gbr.gruppLekID).Count();
            return search;
        }
        /// <summary>
        /// Hämtar  ut lediga platser för privatlektioner.
        /// </summary>
        /// <param name="id"></param>
        /// <param name="week"></param>
        /// <returns></returns>
        public int CheckAvailablePri(int id, int week)
        {
            var search = (from pbr in db.PBokningsRads
                          where pbr.privatLekID == id && pbr.vecka == week.ToString()
                          select pbr.privatLekID).Count();
            return search;
        }
        /// <summary>
        /// Hämtar ut IDn för grupplektioner.
        /// </summary>
        /// <returns></returns>
        public List<int> GetLessonIds()
        {
            var search = (from gl in db.GruppLektions
                          select gl.gruppLekID);
            return search.ToList<int>();
        }
        /// <summary>
        /// Hämtar ut IDn för privatlektioner.
        /// </summary>
        /// <returns></returns>
        public List<int> GetPriLessonIds()
        {
            var search = (from pl in db.Privatlektions
                          select pl.privatLekID);
            return search.ToList<int>();
        }
        /// <summary>
        /// Hämtar lektionsID för en specifik typ av lektion o period. 
        /// </summary>
        /// <param name="type"></param>
        /// <param name="period"></param>
        /// <returns></returns>
        public List<string> GetSkiLessonId(string type, string period)
        {
            var search = (from lp in db.GruppLektions
                          where lp.gruppTyp == type && lp.period == period
                          select lp.gruppLekID.ToString());
            return search.ToList<string>();
        }
        /// <summary>
        /// Hämtar priset för grupplektioner
        /// </summary>
        /// <param name="type"></param>
        /// <param name="period"></param>
        /// <returns></returns>
        public List<string> GetSkiLessonPrice(string type, string period)
        {
            var search = (from lp in db.GruppLektions
                          where lp.gruppTyp == type && lp.period == period
                          select lp.pris.ToString());
            return search.ToList<string>();
        }
        /// <summary>
        /// Hämtar priset för privatlektioner
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public List<string> GetSkiLessonPrice(string id)
        {
            var search = (from lp in db.Privatlektions
                          where lp.privatLekID == int.Parse(id)
                          select lp.pris.ToString());
            return search.ToList<string>();
        }
        /// <summary>
        /// Kontroll om den specifika valda grupplektionen existerar. 
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public bool CheckGroup(string type)
        {
            var search = (from g in db.GruppLektions
                          where g.gruppTyp == type
                          select g.gruppTyp).Count();

            if (search == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        /// <summary>
        /// Kontroll om den specifika valda perioden existerar.
        /// </summary>
        /// <param name="period"></param>
        /// <returns></returns>
        public bool CheckPeriod(string period)
        {
            var search = (from p in db.GruppLektions
                          where p.period == period
                          select p.period).Count();

            if (search == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        /// <summary>
        /// Kontroll om den specifika privatlektionsID:t existerar. 
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public bool CheckId(string id)
        {
            var search = (from i in db.Privatlektions
                          where i.privatLekID.ToString() == id
                          select i.privatLekID).Count();

            if (search == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
            
        }
        /// <summary>
        /// Skapar ny lektionsbokning för företag
        /// </summary>
        /// <param name="gästNr"></param>
        /// <param name="staffId"></param>
        /// <param name="name"></param>
        /// <param name="price"></param>
        public void NewSkiBookCompany(int gästNr, int staffId, string name, int price)
        {
            SkiBokning skiBook = new SkiBokning(); 

            try
            {
                using (TransactionScope scope = new TransactionScope())
                {
                    skiBook.gästNr = gästNr;
                    skiBook.personalID = staffId;
                    skiBook.namn = name;
                    skiBook.pris = price;

                    db.SkiBoknings.InsertOnSubmit(skiBook);
                    db.SubmitChanges();

                    scope.Complete();
                }
            }
            catch
            {
                db.SkiBoknings.DeleteOnSubmit(skiBook);
            }
        }
        /// <summary>
        /// Skapar ny lektionsbokning för privatgäst
        /// </summary>
        /// <param name="staffId"></param>
        /// <param name="name"></param>
        /// <param name="price"></param>
        public void NewSkiBookPrivate(int staffId, string name, int price)
        {
            SkiBokning skiBook = new SkiBokning(); // Skapar ny bokning

            try
            {
                using (TransactionScope scope = new TransactionScope())
                {
                    skiBook.personalID = staffId;
                    skiBook.namn = name;
                    skiBook.pris = price;

                    db.SkiBoknings.InsertOnSubmit(skiBook);
                    db.SubmitChanges();

                    scope.Complete();
                }
            }
            catch
            {
                db.SkiBoknings.DeleteOnSubmit(skiBook);
            }
        }
        /// <summary>
        /// Skapar ny bokningsrad för gruppbokning
        /// </summary>
        /// <param name="bookId"></param>
        /// <param name="lesId"></param>
        /// <param name="name"></param>
        /// <param name="price"></param>
        /// <param name="week"></param>
        public void NewSkiGroupRow(int bookId, int lesId, string name, int price, string week)
        {
            GBokningsRad gbr = new GBokningsRad(); 

            gbr.skiBokningNr = bookId;
            gbr.gruppLekID = lesId;
            gbr.namn = name;
            gbr.pris = price;
            gbr.vecka = week;

            db.GBokningsRads.InsertOnSubmit(gbr);
            db.SubmitChanges();
        }
        /// <summary>
        /// Skapar ny bokningsrad för privatlektioner
        /// </summary>
        /// <param name="bookId"></param>
        /// <param name="lesId"></param>
        /// <param name="name"></param>
        /// <param name="price"></param>
        /// <param name="week"></param>
        public void NewSkiPrivateRow(int bookId, int lesId, string name, int price, string week)
        {
            PBokningsRad pbr = new PBokningsRad(); // Skapar ny uthyrningsrad

            pbr.skiBokningNr = bookId;
            pbr.privatLekID = lesId;
            pbr.namn = name;
            pbr.pris = price;
            pbr.vecka = week;

            db.PBokningsRads.InsertOnSubmit(pbr);
            db.SubmitChanges();
        }
        /// <summary>
        /// Hämtar senaste bokningsnumret för skidlektion
        /// </summary>
        /// <returns></returns>
        public int GetSkiBookNumber()
        {
            var search = (from sb in db.SkiBoknings
                          select sb.skiBokningNr).Max();
            return search;
        }
        /// <summary>
        /// Hämtar samtliga grupplektioner
        /// </summary>
        /// <returns></returns>
        public IQueryable GetGroupLesson()
        {
            var search = from gl in db.GruppLektions
                         select gl;
            return search;
        }
        /// <summary>
        /// Hämtar samtliga privatlektioner
        /// </summary>
        /// <returns></returns>
        public IQueryable GetPrivateLesson()
        {
            var search = from pl in db.Privatlektions
                         select pl;
            return search;
        }
        /// <summary>
        /// Ändrar priset för specifik grupplektion 
        /// </summary>
        /// <param name="tempId"></param>
        /// <param name="tempPeriod"></param>
        /// <param name="tempLevel"></param>
        /// <param name="tempPrice"></param>
        public void ChangedGroupLesson(int tempId, string tempPeriod, string tempLevel, int tempPrice)
        {
            var search = from gl in db.GruppLektions
                         where gl.gruppLekID == tempId && gl.period == tempPeriod && gl.gruppTyp == tempLevel
                         select gl;

            foreach (GruppLektion gl in search)
            {
                gl.pris = tempPrice;
            }

            db.SubmitChanges();
        }
        /// <summary>
        /// ändrar priset för specifik privatlektion. 
        /// </summary>
        /// <param name="tempId"></param>
        /// <param name="tempPrice"></param>
        public void ChangedPrivateLesson(int tempId, int tempPrice)
        {
            var search = from pl in db.Privatlektions
                         where pl.privatLekID == tempId
                         select pl;

            foreach (Privatlektion pl in search)
            {
                pl.pris = tempPrice;
            }

            db.SubmitChanges();
        }

        #endregion

        //************************************************************ Statistik och budget ****************************************************//
        #region
        /// <summary>
        /// Kollar om det finns en budgetsrad inlagd för den angivna perioden. 
        /// </summary>
        /// <param name="tempYear"></param>
        /// <param name="tempWeek"></param>
        /// <returns></returns>
        public bool CheckBudgetYearAndWeek(int tempYear, int tempWeek)
        {
            var search = from i in db.Intäkts
                         where i.år == tempYear && i.vecka == tempWeek
                         select i;
            foreach (var i in search)
                return true;
            return false;
        }
        /// <summary>
        /// Skapar ny budgetsrad
        /// </summary>
        /// <param name="year"></param>
        /// <param name="week"></param>
        /// <param name="type"></param>
        /// <returns></returns>

        public Intäkt NewBudget(int year, int week, string type)
        {
            Intäkt newbudget = new Intäkt(); 

            newbudget.år = year;
            newbudget.vecka = week;
            newbudget.typ = type;
            newbudget.progIntäkt = 0;
            newbudget.budgIntäkt = 0;

            db.Intäkts.InsertOnSubmit(newbudget);
            db.SubmitChanges();

            return newbudget;
        }
        /// <summary>
        /// Hämtar budgetrad för specifik period
        /// </summary>
        /// <param name="tempYear"></param>
        /// <param name="tempWeek"></param>
        /// <returns></returns>

        public IQueryable GetBudgetByYearAndWeek(int tempYear, int tempWeek)
        {
            var search = from i in db.Intäkts
                         where i.år == tempYear && i.vecka == tempWeek
                         select i;
            return search;
        }

        /// <summary>
        /// Metod för att ändra intäkten för en specifik budgetsrad.
        /// </summary>
        /// <param name="tempYear"></param>
        /// <param name="tempWeek"></param>
        /// <param name="tempType"></param>
        /// <param name="tempBudg"></param>
        public void ChangedBudget(int tempYear, int tempWeek, string tempType, int tempBudg)
        {
            var search = from i in db.Intäkts
                         where i.år == tempYear && i.vecka == tempWeek && i.typ == tempType
                         select i;

            foreach (Intäkt i in search)
            {
                i.budgIntäkt = tempBudg;
            }

            db.SubmitChanges();
        }
        /// <summary>
        /// Sätter beläggningsgraden för vald typ  av logi och period. 
        /// </summary>
        /// <param name="tempYear"></param>
        /// <param name="tempWeek"></param>
        /// <param name="tempType"></param>
        public void SetOccupancylevelLodging(int tempYear, int tempWeek, string tempType)
        {
            decimal occupancy;
            if (tempType.Length > 5)
            {

                int lsearch =  (from lb in db.LBokningsRads
                               where lb.logiID.StartsWith("LII") && lb.veckoNr == tempWeek
                               select lb).Count();

                int tsearch = (from lt in db.LogiTyps
                               where lt.logiTyp1 == tempType
                               select lt.antal).SingleOrDefault().Value;

                if (lsearch == 0)
                {
                    occupancy = 0;
                }
                else
                {
                    occupancy = (((decimal)lsearch / (decimal)tsearch) * (decimal)100);
                }

                var search = from i in db.Intäkts
                             where i.år == tempYear && i.vecka == tempWeek && i.typ == tempType
                             select i;

                foreach (Intäkt i in search)
                {
                    i.beläggningsgrad = Convert.ToInt32(occupancy);
                }

                db.SubmitChanges();

            }
            else if (tempType[0] == 'C')
            {
                int lsearch = (from lb in db.LBokningsRads
                               where lb.logiID.StartsWith("C") && lb.veckoNr == tempWeek
                               select lb).Count();

                int tsearch = (from lt in db.LogiTyps
                               where lt.logiTyp1 == tempType
                               select lt.antal).SingleOrDefault().Value;

                if (lsearch == 0)
                {
                    occupancy = 0;
                }
                else
                {
                    occupancy = (((decimal)lsearch / (decimal)tsearch) * (decimal)100);
                }
                var search = from i in db.Intäkts
                             where i.år == tempYear && i.vecka == tempWeek && i.typ == tempType
                             select i;

                foreach (Intäkt i in search)
                {
                    i.beläggningsgrad = Convert.ToInt32(occupancy);
                }
                db.SubmitChanges();
            }
            else
            {
                int lsearch = (from lb in db.LBokningsRads
                               where !lb.logiID.StartsWith("C") && !lb.logiID.StartsWith("LII") && lb.veckoNr == tempWeek
                               select lb).Count();

                int tsearch = (from lt in db.LogiTyps
                               where lt.logiTyp1 == tempType
                               select lt.antal).SingleOrDefault().Value;

                if (lsearch == 0)
                {
                    occupancy = 0;                   
                }
                else
                {
                   occupancy = (((decimal)lsearch / (decimal)tsearch) * (decimal)100);                                      
                }

                var search = from i in db.Intäkts
                             where i.år == tempYear && i.vecka == tempWeek && i.typ == tempType
                             select i;

                foreach (Intäkt i in search)
                {
                    i.beläggningsgrad = Convert.ToInt32(occupancy);
                }

                db.SubmitChanges();
            } 
       }
        /// <summary>
        /// Sätter beläggningsgraden för vald typ  av konferenser och period. 
        /// </summary>
        /// <param name="tempYear"></param>
        /// <param name="tempWeek"></param>
        /// <param name="tempType"></param>
        public void SetOccupancylevelConference(int tempYear, int tempWeek, string tempType)
        {
            decimal occupancy;
            if (tempType[0] == 'l')
            {
                int ksearch = (from kb in db.KBokningsRads
                               where kb.konferensID.StartsWith("l") && kb.veckoNr == tempWeek
                               select kb).Count();

                int tsearch = (from kt in db.KonferensTyps
                               where kt.konferensTyp1 == tempType
                               select kt.antal).SingleOrDefault().Value;

                if (ksearch == 0)
                {
                    occupancy = 0;
                }
                else
                {
                    occupancy = (((decimal)ksearch / (decimal)tsearch) * (decimal)100);
                }

                var search = from i in db.Intäkts
                             where i.år == tempYear && i.vecka == tempWeek && i.typ == tempType
                             select i;

                foreach (Intäkt i in search)
                {
                    i.beläggningsgrad = Convert.ToInt32(occupancy);
                }

                db.SubmitChanges();

            }
            else
            {
                int ksearch = (from kb in db.KBokningsRads
                               where kb.konferensID.StartsWith("s") && kb.veckoNr == tempWeek
                               select kb).Count();

                int tsearch = (from kt in db.KonferensTyps
                               where kt.konferensTyp1 == tempType
                               select kt.antal).SingleOrDefault().Value;

                if (ksearch == 0)
                {
                    occupancy = 0;
                }
                else
                {
                    occupancy = (((decimal)ksearch / (decimal)tsearch) * (decimal)100);
                }

                var search = from i in db.Intäkts
                             where i.år == tempYear && i.vecka == tempWeek && i.typ == tempType
                             select i;

                foreach (Intäkt i in search)
                {
                    i.beläggningsgrad = Convert.ToInt32(occupancy);
                }
                db.SubmitChanges();
            }
        }
        /// <summary>
        /// Hämtar beläggningsgrad från tabellen för vald period och typ. 
        /// </summary>
        /// <param name="tempYear"></param>
        /// <param name="fromWeek"></param>
        /// <param name="toWeek"></param>
        /// <param name="tempType"></param>
        /// <returns></returns>
        public IQueryable GetOccupancyLevel(int tempYear, int fromWeek, int toWeek, string tempType)
        {
            var search = from i in db.Intäkts
                         where i.år == tempYear && i.vecka >= fromWeek &&  i.vecka <= toWeek && i.typ == tempType
                         select i;
            return search;
        }
        /// <summary>
        /// Hämtar beläggningsgrad från tabellen för vintersäsongen o vald typ. 
        /// </summary>
        /// <param name="tempYear"></param>
        /// <param name="fromWeek"></param>
        /// <param name="toWeek"></param>
        /// <param name="tempType"></param>
        /// <returns></returns>
        public IQueryable GetOccupancyLevelWinter(int tempYear, int fromWeek, int toWeek, string tempType)
        {
            var search = from i in db.Intäkts
                         where i.år == tempYear && i.vecka < fromWeek || i.vecka > toWeek && i.typ == tempType
                         select i;
            return search;
        }
        #endregion
        //*****************************************************************Användare************************************************************//
        #region
        /// <summary>
        /// Hämtar samtliga användare i databasen
        /// </summary>
        /// <returns></returns>
        public IQueryable GetAllStaff()
        {
            var search = from p in db.Personals
                         select p;
            return search;
        }

        /// <summary>
        /// Skapar ny användare 
        /// </summary>
        /// <param name="tempFName"></param>
        /// <param name="tempLName"></param>
        /// <param name="tempAccess"></param>
        /// <param name="tempPassword"></param>
        /// <returns></returns>
        public Personal NewStaff(string tempFName, string tempLName, string tempAccess, string tempPassword)
        {
            Personal newStaff = new Personal(); 

            newStaff.förnamn = tempFName;
            newStaff.efternamn = tempLName;
            newStaff.behörighet = tempAccess;
            newStaff.lösenord = tempPassword;

            db.Personals.InsertOnSubmit(newStaff);
            db.SubmitChanges();

            return newStaff;
        }
        /// <summary>
        /// Ändra befintlig användare
        /// </summary>
        /// <param name="tempId"></param>
        /// <param name="tempFName"></param>
        /// <param name="tempLName"></param>
        /// <param name="tempAccess"></param>
        /// <param name="tempPassword"></param>
        public void ChangedStaff(int tempId, string tempFName, string tempLName, string tempAccess, string tempPassword)
        {
            var search = from p in db.Personals
                         where p.personalID == tempId
                         select p;

            foreach (Personal p in search)
            {
                p.förnamn = tempFName;
                p.efternamn = tempLName;
                p.behörighet = tempAccess;
                p.lösenord = tempPassword;
            }

            db.SubmitChanges();
        }
        /// <summary>
        /// Hämta användare från ID
        /// </summary>
        /// <param name="tempId"></param>
        /// <returns></returns>
        public IQueryable GetStaffById(int tempId)
        {
            var search = from p in db.Personals
                         where p.personalID == tempId
                         select p;
            return search;
        }
        /// <summary>
        /// Hämtar användare från förnamn
        /// </summary>
        /// <param name="tempFName"></param>
        /// <returns></returns>
        public IQueryable GetStaffByFName(string tempFName)
        {
            if (tempFName.StartsWith("*") && tempFName.EndsWith("*"))
            {
                var search = from p in db.Personals
                             where p.förnamn.Contains(tempFName.Split('*')[1])
                             select p;
                return search;
            }
            else if (tempFName.StartsWith("*"))
            {
                var search = from p in db.Personals
                             where p.förnamn.EndsWith(tempFName.Split('*')[1])
                             select p;
                return search;
            }
            else if (tempFName.EndsWith("*"))
            {
                var search = from p in db.Personals
                             where p.förnamn.StartsWith(tempFName.Split('*')[0])
                             select p;
                return search;
            }
            else
            {
                var search = from p in db.Personals
                             where p.förnamn == tempFName
                             select p;
                return search;
            }
        }
        /// <summary>
        /// Hämtar anvädnare från efternamn
        /// </summary>
        /// <param name="tempLName"></param>
        /// <returns></returns>
        public IQueryable GetStaffByLName(string tempLName)
        {
            if (tempLName.StartsWith("*") && tempLName.EndsWith("*"))
            {
                var search = from p in db.Personals
                             where p.efternamn.Contains(tempLName.Split('*')[1])
                             select p;
                return search;
            }
            else if (tempLName.StartsWith("*"))
            {
                var search = from p in db.Personals
                             where p.efternamn.EndsWith(tempLName.Split('*')[1])
                             select p;
                return search;
            }
            else if (tempLName.EndsWith("*"))
            {
                var search = from p in db.Personals
                             where p.efternamn.StartsWith(tempLName.Split('*')[0])
                             select p;
                return search;
            }
            else
            {
                var search = from p in db.Personals
                             where p.efternamn == tempLName
                             select p;
                return search;
            }
        }
        /// <summary>
        ///returnerar det skapade personalId:et
        /// </summary>
        /// <returns></returns>
        public int GetStaffNr() 
        {
            var search = (from p in db.Personals
                          select p.personalID).Max() + 1;
            return search;
        }
        #endregion
        //****************************************************************FAKTURERING***********************************************************//
        #region
        /// <summary>
       /// Hämtar fakturor som ska skrivas ut
       /// </summary>
       /// <returns></returns>
        public List<string> Invoices()
        {
            List<string> invoices = new List<string>();

            var search = from i in db.Fakturas
                         where i.utskriftsDatum == DateTime.Today.Date
                         select new
                         {
                             invoiceID = i.fakturaNr,
                             guestNr = i.gästNr,
                             printDate = i.utskriftsDatum,
                             bookingID = i.bokningsNr,
                             invoiceType = i.fakturaTyp

                         };
            foreach (var i in search)
                {
                invoices.Add(i.invoiceType.ToString()+"\t" +i.invoiceID.ToString() +"\t" + i.bookingID+ "\t" + i.guestNr.ToString() + "\t" + i.printDate.Value.ToShortDateString()+"\n" );
                }

            return invoices;
        }

         /// <summary>
         /// Hämtar bokningsraden från samtliga som ska faktureras.
         /// </summary>
         /// <param name="bookingID"></param>
         /// <returns></returns>

        public List<string> GetInvoiceBookingRow(int bookingID)
        {
            List<string> bookingRow = new List<string>();
          
            var searchb = from b in db.Boknings
                         // join f in db.Fakturas on b.bokningsNr equals f.bokningsNr
                          where b.bokningsNr == bookingID //&& f.utskriftsDatum == DateTime.Today.Date
                          select new
                          {
                              bookingID = b.bokningsNr,
                              cancelProtection = b.avbokningsskydd,
                              discount = b.rabatt,
                              totalSum = b.totSum
                          };

            foreach (var b in searchb)
            {  
                if (b.cancelProtection == true && b.discount == 0)
                {
                    bookingRow.Add("Bokningsnr: " + "\t" + b.bookingID + "\t\t" + "Avb.skydd: Ja" + "\t\t\t" + "Summa: " + b.totalSum );
                }
                else if (b.cancelProtection == false && b.discount == 0)
                {
                    bookingRow.Add("Bokningsnr: " + "\t" + b.bookingID + "\t\t" + "Avb.skydd: Nej" + "\t\t\t" + "Summa: " + b.totalSum );
                }
                else if (b.cancelProtection == true && b.discount != 0)
                {
                    bookingRow.Add("Bokningsnr: " + "\t" + b.bookingID + "\t\t" + "Avb.skydd: Ja" + "\t" + "Rabatt: " + b.discount + "%" + "\t" + "Summa: " + b.totalSum );
                }
                else if (b.cancelProtection == false && b.discount != 0)
                {
                    bookingRow.Add("Bokningsnr: " + "\t" + b.bookingID + "\t\t" + "Avb.skydd: Nej" + "\t" + "Rabatt: " + b.discount + "%" + "\t" + "Summa: " + b.totalSum);
                }
            }
            return bookingRow;
        }

        /// <summary>
        /// Hämtar samtliga konferensrader från konferenser till fakturutskrift
        /// </summary>
        /// <param name="bookingID"></param>
        /// <returns></returns>
        public List<string> GetInvoiceConferenceBookingRows(int bookingID)
        {
            List<string> conferenceBookingRows = new List<string>();
          
            var searchkb = from kb in db.KBokningsRads
                           //join f in db.Fakturas on kb.bokningsNr equals f.bokningsNr
                           where kb.bokningsNr == bookingID //&& f.utskriftsDatum == DateTime.Today.Date
                          select new
                          {
                               
                              conferenceID = kb.konferensID,
                              startDate = kb.frånDatum,
                              endDate = kb.tillDatum,
                              conferencePrice = kb.pris       
                          };

            foreach (var kb in searchkb)
            {
                if (kb.conferenceID[0] == 'l' && kb.startDate.Date != kb.endDate.Date)
                {
                    conferenceBookingRows.Add("Konferensrum:" + "\t" + "Lillbacken" + "\t" + "Från:" + kb.startDate.ToShortDateString() + "\t" + "Till:" + kb.endDate.ToShortDateString() + "\t" + "Pris: " + kb.conferencePrice);
                }
                else if (kb.conferenceID[0] == 's' && kb.startDate.Date != kb.endDate.Date)
                {
                    conferenceBookingRows.Add("Konferensrum:" + "\t" + "Storbacken" + "\t" + "Från:" + kb.startDate.ToShortDateString() + "\t" + "Till:" + kb.endDate.ToShortDateString() + "\t" + "Pris: " + kb.conferencePrice);
                }

                else if (kb.conferenceID[0] == 'l' && kb.startDate.Date == kb.endDate.Date)
                {
                    conferenceBookingRows.Add("Konferensrum:" + "\t" + "Lillbacken" + "\t" + "Datum:" + kb.startDate.ToShortDateString()+ "\t"+"Antal timmar: "+kb.endDate.Subtract(kb.startDate).Hours + "\t" + "Pris: " + kb.conferencePrice);
                }
                else if (kb.conferenceID[0] == 's' && kb.startDate.Date == kb.endDate.Date)
                {
                    conferenceBookingRows.Add("Konferensrum:" + "\t" + "Storbacken" + "\t" + "Datum:" +kb.startDate.ToShortDateString()+ "\t"+"Antal timmar: "+ kb.endDate.Subtract(kb.startDate).Hours + "\t" + "Pris: " + kb.conferencePrice);
                }
            }

       
            return conferenceBookingRows;
        }
        /// <summary>
        /// Hämtar samtliga logibokningsrader för fakturautskrift.
        /// </summary>
        /// <param name="bookingID"></param>
        /// <returns></returns>
        public List<string> GetInvoiceLodgingBookingRows(int bookingID)
        {
            List<string> lodgingBookingRows = new List<string>();

            var searchlb = from lb in db.LBokningsRads
                           //join f in db.Fakturas on lb.bokningsNr equals f.bokningsNr
                           where lb.bokningsNr == bookingID //&& f.utskriftsDatum == DateTime.Today.Date
                           select new
                           {
                               lodgingID = lb.logiID,
                               startDate = lb.frånDatum,
                               endDate = lb.tillDatum,
                               lodgingPrice = lb.pris
                           };
            foreach (var lb in searchlb)
            {
                if (lb.lodgingID[2] == 'I' && lb.startDate.Date != lb.endDate.Date)
                {
                    lodgingBookingRows.Add("Logialternativ:" + "\t" + "LGH II" + "\t\t" + "Från:" + lb.startDate.ToShortDateString() + "\t" + "Till:" + lb.endDate.ToShortDateString() + "\t" + "Pris: " + lb.lodgingPrice);
                }
                else if (lb.lodgingID[2] != 'I' && lb.startDate.Date != lb.endDate.Date)
                {
                    lodgingBookingRows.Add("Logialternativ:" + "\t" + "LGH I" + "\t\t" + "Från:" + lb.startDate.ToShortDateString() + "\t" + "Till:" + lb.endDate.ToShortDateString() + "\t" + "Pris: " + lb.lodgingPrice);
                }
                else if (lb.lodgingID[2] == 'I' && lb.startDate.Date == lb.endDate.Date)
                {
                    lodgingBookingRows.Add("Logialternativ:"+"\t"+"LGH I" + "\t\t" + "Från:" + lb.startDate + "\t" + "Till:" + lb.endDate + "\t" + "Pris: " + lb.lodgingPrice);
                }
                else if (lb.lodgingID[2] != 'I' && lb.startDate.Date == lb.endDate.Date)
                {
                    lodgingBookingRows.Add("Logialternativ:" + "\t" + "LGH I" + "\t\t" + "Från:" + lb.startDate + "\t" + "Till:" + lb.endDate + "\t" + "Pris: " + lb.lodgingPrice);
                }
            }
            return lodgingBookingRows ;
        }

        /// <summary>
        /// Skapar faktura för logi
        /// </summary>
        /// <param name="bookingID"></param>
        /// <param name="type"></param>
        /// <returns></returns>

        public Faktura CreateLodgingInvoice(int bookingID, string type)
        {
            string tomorrow = DateTime.Now.Date.AddDays(1).AddHours(8).ToString();

            var guestNr = (from b in db.Boknings
                           where b.bokningsNr == bookingID
                           select b.gästNr).FirstOrDefault();
            var personalID = (from b in db.Boknings
                              where b.bokningsNr == bookingID
                              select b.personalID).FirstOrDefault();


            var totSum = (from b in db.Boknings
                          where b.bokningsNr == bookingID
                          select b.totSum).FirstOrDefault();


            Faktura newInvoice = new Faktura(); // Skapar en ny faktura

            newInvoice.bokningsNr = bookingID;
            Faktura bookingToInvoice = db.Fakturas.SingleOrDefault(b => b.bokningsNr == bookingID);
            newInvoice.utskriftsDatum = DateTime.Today.Date;//Convert.ToDateTime(tomorrow);
            newInvoice.förfalloDatum = newInvoice.utskriftsDatum.Value.AddDays(30);
            if (type == "a")
            {
                newInvoice.totalSumma = Convert.ToInt32(totSum * (decimal)0.15);

            }
            if (type == "b")
            {
                newInvoice.totalSumma = Convert.ToInt32(totSum * (decimal)0.85);

            }
            if (type == "c")
            {
                newInvoice.totalSumma = (int)totSum;

            }
            newInvoice.gästNr = Convert.ToInt32(guestNr);
            newInvoice.personalID = Convert.ToInt32(personalID);
            db.Fakturas.InsertOnSubmit(newInvoice);
            newInvoice.fakturaTyp = type;
            db.SubmitChanges();
            return newInvoice; // Returnerar fakturan
        }
        /// <summary>
        /// Skapar en sammanställd faktura för logi o uthyrning. (Denna ska skapas när företag hyr utrustning mot faktura o när gäster lägger till bokningar på plats)
        /// </summary>
        /// <param name="tempID"></param>
        /// <param name="guestNr"></param>
        /// <param name="invoiceType"></param>
        /// <param name="price"></param>
        /// <param name="type"></param>
        /// <param name="staffID"></param>
        /// <returns></returns>
        public Faktura CreateSumInvoice(int tempID, int guestNr, string invoiceType, int price, string type, int staffID) // FUNKAR INTE ÄN
        {
            DateTime startDate = DateTime.Today.Date;



            Faktura newInvoice = new Faktura(); // Skapar en ny faktura

            if (type == "rent")
            {
                newInvoice.uthyrningsNr = tempID;
                Faktura bookingToInvoice = db.Fakturas.SingleOrDefault(b => b.uthyrningsNr == tempID);
                newInvoice.utskriftsDatum = startDate.AddDays(7);
            }
            else
            {
                newInvoice.bokningsNr = tempID;
                Faktura bookingToInvoice = db.Fakturas.SingleOrDefault(b => b.bokningsNr == tempID);
                DateTime start = (from lb in db.LBokningsRads
                                  join b in db.Boknings on lb.bokningsNr equals b.bokningsNr
                                  orderby lb.frånDatum descending
                                  where guestNr == b.gästNr
                                  select lb.frånDatum).FirstOrDefault();
                DateTime end = (from lb in db.LBokningsRads
                                join b in db.Boknings on lb.bokningsNr equals b.bokningsNr
                                orderby lb.frånDatum descending
                                where guestNr == b.gästNr
                                select lb.tillDatum).FirstOrDefault();

                if (DateTime.Today.Date > start && DateTime.Today.Date < end)
                {
                    newInvoice.utskriftsDatum = startDate.AddDays(7);
                    newInvoice.förfalloDatum = startDate.AddDays(37);
                }

                else
                {
                    newInvoice.utskriftsDatum = startDate.AddDays(1);
                    newInvoice.förfalloDatum = startDate.AddDays(31);
                }

            }


            newInvoice.totalSumma = price;
            newInvoice.gästNr = guestNr;
            newInvoice.personalID = staffID;
            newInvoice.fakturaTyp = invoiceType;
            db.Fakturas.InsertOnSubmit(newInvoice);
            db.SubmitChanges();

            return newInvoice; // Returnerar fakturan
        }
        /// <summary>
        /// Hämtar fakturadetaljer
        /// </summary>
        /// <param name="bookingID"></param>
        /// <returns></returns>
        public List<string> GetInvoice(int bookingID)
        {
            List<string> InvoiceDetails = new List<string>();
            var search = from i in db.Fakturas
                         join b in db.Boknings
                         on i.bokningsNr equals b.bokningsNr
                         join p in db.Personals
                         on i.personalID equals p.personalID
                         join g in db.Gästs
                         on b.gästNr equals g.gästNr
                         where i.bokningsNr == bookingID && b.bokningsNr == bookingID

                         select new
                         {
                             invoicenr = i.fakturaNr,
                             guestNr = i.gästNr,
                             guestName = g.förNamn + "\t" + g.efterNamn,
                             guestAdress = g.gatuAdress,
                             guestZipAndCity = g.postNr + g.ort,
                             staffname = p.förnamn + "\t" + p.efternamn,
                             discount = b.rabatt,
                             printDate = i.utskriftsDatum.Value.ToShortDateString(),
                             payDate = i.förfalloDatum.Value.ToShortDateString(),
                             totalSum = Convert.ToInt32(i.totalSumma),
                             fakturaTyp = i.fakturaTyp
                         };
            //if (search.Count() == 2)


            foreach (var i in search)
            {
                if (i.discount == 0)
                {
                    InvoiceDetails.Add(i.fakturaTyp + "\t" + i.invoicenr + "\t" + i.guestNr + "\t" + i.guestName + "\t" + i.guestAdress + "\t" + i.guestZipAndCity + "\t" + i.staffname + "\t" + i.printDate + "\t" + i.payDate + "\t" + i.totalSum + "\t" + "0");
                }

                else

                    InvoiceDetails.Add(i.fakturaTyp + "\t" + i.invoicenr + "\t" + i.guestNr + " " + i.guestName + "\t" + i.guestAdress + "\t" + i.guestZipAndCity + "\t" + i.staffname + "\t" + i.printDate + "\t" + i.payDate + "\t" + i.totalSum + "\t" + i.discount);
            }
            return InvoiceDetails;
        }
        /// <summary>
        /// Kollar ifall om en gäst har en existerande faktura
        /// </summary>
        /// <param name="guestNr"></param>
        /// <param name="today"></param>
        /// <returns></returns>
        public bool InvoiceExistCheck(int guestNr, DateTime today)
        {
            var search =
                (from f in db.Fakturas
                 where f.gästNr == guestNr && f.utskriftsDatum > today
                 select f.bokningsNr).Count();

            if (search == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        /// <summary>
        /// Kontroll av gästens faktura som kollar ifall fakturans utskriftsdatumet är senare än bokningsdagen. (När man bokar på plats, finns den en faktura som inte är utskriven än läggs bokningen på den, om inte skapas en ny)
        /// </summary>
        /// <param name="guestNr"></param>
        /// <param name="today"></param>
        /// <returns></returns>
        public bool InvoicePrintDateLaterThanBookingDayCheck(int guestNr, DateTime today)
        {
            var search =
               (from f in db.Fakturas
                where f.gästNr == guestNr && f.utskriftsDatum > today
                select f.bokningsNr).Count();

            if (search == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        /// <summary>
        /// Kollar om det finns en existerande faktura som inte är utskriven än för uthyrning. 
        /// </summary>
        /// <param name="guestNr"></param>
        /// <param name="today"></param>
        /// <returns></returns>
        public int InvoiceExistForRentalCheck(int guestNr, DateTime today)
        {
            var search = (from f in db.Fakturas
                          where f.gästNr == guestNr && f.utskriftsDatum > today
                          select f.fakturaNr).FirstOrDefault();
            return search;
        }


        /// <summary>
        /// Hämtar specifik bokningsID för faktura
        /// </summary>
        /// <param name="guestNr"></param>
        /// <param name="today"></param>
        /// <returns></returns>
        public int GetBookingIDForInvoice(int guestNr, DateTime today)
        {
            int search =
                    (from f in db.Fakturas
                     where f.gästNr == guestNr && f.utskriftsDatum > today
                     select f.bokningsNr).FirstOrDefault().Value;
            return search;
        }
        /// <summary>
        /// Kontroll om det existar någon uthyrningsnr i en faktura för en specifik gäst, där fakturan inte är utskriven än. 
        /// </summary>
        /// <param name="guestNr"></param>
        /// <param name="today"></param>
        /// <returns></returns>
        public bool CheckRentalIDForInvoice(int guestNr, DateTime today)
        {
            var search =
                     (from f in db.Fakturas
                      where f.gästNr == guestNr && f.utskriftsDatum > today && f.fakturaTyp == "c"
                      select f.uthyrningsNr).FirstOrDefault();
            if (search == null)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        /// <summary>
        /// Hämta uthyrningsnumret för fakturan för en specifik företagsgäst. 
        /// </summary>
        /// <param name="guestNr"></param>
        /// <param name="today"></param>
        /// <returns></returns>
        public int GetRentalIDForInvoice(int guestNr, DateTime today)
        {
            int search =
                (from u in db.Uthyrnings
                 where guestNr == u.gästNr
                 select u.uthyrningsNr).FirstOrDefault();


            return search;
        }
        /// <summary>
        /// Kontroll ifall bokningsdagen är mer än 30 dagar ifrån då gästen ska komma. (Är det mindre skickar man båda fakturorna på en gång)
        /// </summary>
        /// <param name="guestNr"></param>
        /// <param name="bookingID"></param>
        /// <returns></returns>
        public bool PeriodBeforeStartDateCheck(int guestNr, int bookingID)
        {
            DateTime search = (from b in db.Boknings
                               join lb in db.LBokningsRads
                               on b.bokningsNr equals lb.bokningsNr
                               where b.bokningsNr == bookingID
                               select lb.frånDatum).FirstOrDefault();

            TimeSpan timespan = (search.Date.Subtract(DateTime.Today.Date));
            if (timespan.Days >= 30)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// Sätter bokningsnr till null när man ändrar/tar bort en bokning, när man ändrat får man en ny bokning med nytt bokningsnr. 
        /// </summary>
        /// <param name="guestNr"></param>
        public void SetNullBookingIDForInvoice(int guestNr)
        {
            var search = (from f in db.Fakturas
                          where f.gästNr == guestNr
                          select f);


          foreach (Faktura i in search)
            {
              i.gästNr = null;      
                
            }

            db.SubmitChanges();


        }
        #endregion
    }

}




